{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "DQN中有两个关键技术，一个是经验回放，一个是双网络结构（策略网络和目标网络）。DQN算法通过贪婪法直接获得目标Q值，贪婪法通过最大化的方式使Q值快速向可能的优化目标收敛，但是这容易导致过估计Q值的问题，使得模型具有较大的偏差。因此为了避免这种情况的出现，提出了Double DQN算法，采用Double DQN算法解耦动作的选择和目标Q值的计算，以解决过估计Q值的问题。"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义网络模型\n",
    "\n",
    "Double DQN除了在更新时对期望Q值的近似方式与DQN不同之外，其他都是相同的"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-31T09:25:35.422485Z",
     "start_time": "2024-07-31T09:25:34.074198200Z"
    }
   },
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "class Model(nn.Module):\n",
    "    def __init__(self, n_states,n_actions,hidden_dim=256):\n",
    "        \"\"\" 初始化q网络，为全连接网络\n",
    "        \"\"\"\n",
    "        super(Model, self).__init__()\n",
    "        self.fc1 = nn.Linear(n_states, hidden_dim) # 输入层\n",
    "        self.fc2 = nn.Linear(hidden_dim,hidden_dim) # 隐藏层\n",
    "        self.fc3 = nn.Linear(hidden_dim, n_actions) # 输出层\n",
    "        \n",
    "    def forward(self, x):\n",
    "        # 各层对应的激活函数\n",
    "        x = F.relu(self.fc1(x)) \n",
    "        x = F.relu(self.fc2(x))\n",
    "        return self.fc3(x)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义经验回放"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-31T09:25:54.664858500Z",
     "start_time": "2024-07-31T09:25:54.644856200Z"
    }
   },
   "outputs": [],
   "source": [
    "from collections import deque\n",
    "import random\n",
    "class ReplayBuffer(object):\n",
    "    def __init__(self, capacity: int) -> None:\n",
    "        self.capacity = capacity\n",
    "        self.buffer = deque(maxlen=self.capacity)\n",
    "    def push(self,transitions):\n",
    "        ''' 存储transition到经验回放中\n",
    "        '''\n",
    "        self.buffer.append(transitions)\n",
    "    def sample(self, batch_size: int, sequential: bool = False):\n",
    "        if batch_size > len(self.buffer): # 如果批量大小大于经验回放的容量，则取经验回放的容量\n",
    "            batch_size = len(self.buffer)\n",
    "        if sequential: # 顺序采样\n",
    "            rand = random.randint(0, len(self.buffer) - batch_size)\n",
    "            batch = [self.buffer[i] for i in range(rand, rand + batch_size)]\n",
    "            return zip(*batch)\n",
    "        else: # 随机采样\n",
    "            batch = random.sample(self.buffer, batch_size)\n",
    "            return zip(*batch)\n",
    "    def clear(self):\n",
    "        ''' 清空经验回放\n",
    "        '''\n",
    "        self.buffer.clear()\n",
    "    def __len__(self):\n",
    "        ''' 返回当前存储的量\n",
    "        '''\n",
    "        return len(self.buffer)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义策略"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "首先我们知道目前所有基于深度神经网络的更新方式都是梯度下降，如下：\n",
    "$$\n",
    "\\theta_i \\leftarrow \\theta_i - \\lambda \\nabla_{\\theta_{i}} L_{i}\\left(\\theta_{i}\\right)\n",
    "$$\n",
    "那么这个$\\theta$又是什么呢，注意到前面我们讲的DQN跟Q learning算法的一个主要区别就是使用神经网络替代了Q表，而这个$\\theta$实际上就是神经网络的参数，通常用$Q\\left(s_{i}, a_{i} ; \\theta\\right)$表示。根据强化学习的原理我们需要优化的是对应状态下不同动作的长期价值，然后每次选择价值最大对应的动作就能完成一条最优策略，使用神经网络表示Q表时也是如此，我们将输入的状态数作为神经网络的输入层，动作数作为输出层，这样的神经网络表达的功能就跟在Q learning中的Q表是一样的，只不过具有更强的鲁棒性。我们目前讲了参数的更新过程，但是最关键的是损失是如何计算的，在DQN中损失的计算相对来说比较简单，如下：\n",
    "$$\n",
    "L(\\theta)=\\left(y_{i}-Q\\left(s_{i}, a_{i} ; \\theta\\right)\\right)^{2}\n",
    "$$\n",
    "这里的$y_{i}$通常称为期望值，$Q\\left(s_{i}, a_{i} ; \\theta\\right)$称为实际值，这个损失在深度学习中通常称作均方差损失，也就是mseloss，使用这个损失函数通常追溯到数学上的最小二乘法，感兴趣的同学可以了解一下深度学习中的各种损失函数以及各自的使用场景。在DQN中，目标Q值的计算公式如下，$y_{i}$在DQN中一般表示如下：\n",
    "$$\n",
    "y_{i}= \\begin{cases}r_{i} & \\text {对于终止状态} s_{i+1} \\\\ r_{i}+\\gamma \\max _{a^{\\prime}} Q\\left(s_{i+1}, a^{\\prime} ; \\theta\\right) & \\text {对于非终止状态} s_{i+1}\\end{cases}\n",
    "$$\n",
    "该公式的意思就是将下一个状态对应的最大Q值作为实际值（因为实际值通常不能直接求得，只能近似），这种做法实际上只是一种近似，可能会导致过估计等问题。\n",
    "而在Double DQN中，它不直接通过最大化的方式选取目标网络计算的所有可能 Q 值，而是首先通过估计网络选取最大 Q 值对应的动作。目标Q值的最终表示形式如下：\n",
    "$$\n",
    "y_{t}^{DDQN} = r_{t+1} + \\gamma Q\\left(s_{t+1}, \\text{argmax}{a} Q\\left(s_{t+1}, a; \\theta_t\\right); \\theta_{t}^{\\prime}\\right)\n",
    "$$\n",
    "其中，$r_{t+1}$ 是智能体在时刻 $t$ 执行动作 $a_t$ 后获得的实际奖励；$s_{t+1}$ 是智能体在执行动作 $a_t$ 后转移到的下一个状态；$\\gamma$ 是折扣因子；$Q\\left(s_{t+1}, \\text{argmax}{a} Q\\left(s{t+1}, a; \\theta_t\\right); \\theta_{t}^{\\prime}\\right)$ 表示使用当前策略 $\\text{argmax}{a} Q\\left(s{t+1}, a; \\theta_t\\right)$ 计算在下一个状态 $s_{t+1}$ 时的最大动作价值，而这个最大动作价值是使用目标网络 $\\theta_{t}^{\\prime}$ 来计算的。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-31T09:25:58.769105900Z",
     "start_time": "2024-07-31T09:25:58.749232700Z"
    }
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.optim as optim\n",
    "import math\n",
    "import numpy as np\n",
    "\n",
    "class Policy(object):\n",
    "    def __init__(self,cfg):\n",
    "        self.action_dim = cfg.action_dim\n",
    "        self.device = torch.device(cfg.device) \n",
    "        self.gamma = cfg.gamma  # 折扣因子\n",
    "        # e-greedy策略相关参数\n",
    "        self.sample_count = 0  # 用于epsilon的衰减计数\n",
    "        self.epsilon = cfg.epsilon_start\n",
    "        self.update_cnt = 0  \n",
    "        self.epsilon_start = cfg.epsilon_start\n",
    "        self.epsilon_end = cfg.epsilon_end\n",
    "        self.epsilon_decay = cfg.epsilon_decay\n",
    "        self.batch_size = cfg.batch_size\n",
    "        self.target_update = cfg.target_update\n",
    "        self.policy_net = Model(cfg.state_dim,cfg.action_dim,hidden_dim=cfg.hidden_dim).to(self.device)\n",
    "        self.target_net = Model(cfg.state_dim,cfg.action_dim,hidden_dim=cfg.hidden_dim).to(self.device)\n",
    "         # 复制参数到目标网络\n",
    "        for target_param, param in zip(self.target_net.parameters(),self.policy_net.parameters()): \n",
    "            target_param.data.copy_(param.data)\n",
    "        # self.target_net.load_state_dict(self.policy_net.state_dict()) # or use this to copy parameters\n",
    "        self.optimizer = optim.Adam(self.policy_net.parameters(), lr=cfg.lr)  # 优化器\n",
    "        self.memory = ReplayBuffer(cfg.buffer_size) # 经验回放\n",
    "\n",
    "    def sample_action(self, state):\n",
    "        ''' 采样动作\n",
    "        '''\n",
    "        self.sample_count += 1\n",
    "        # epsilon指数衰减\n",
    "        self.epsilon = self.epsilon_end + (self.epsilon_start - self.epsilon_end) * \\\n",
    "            math.exp(-1. * self.sample_count / self.epsilon_decay) \n",
    "        if random.random() > self.epsilon:\n",
    "            with torch.no_grad():\n",
    "                state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n",
    "                q_values = self.policy_net(state)\n",
    "                action = q_values.max(1)[1].item() # choose action corresponding to the maximum q value\n",
    "        else:\n",
    "            action = random.randrange(self.action_dim)\n",
    "        return action\n",
    "    @torch.no_grad() # 不计算梯度，该装饰器效果等同于with torch.no_grad()：\n",
    "    def predict_action(self, state):\n",
    "        ''' 预测动作\n",
    "        '''\n",
    "        state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n",
    "        q_values = self.policy_net(state)\n",
    "        action = q_values.max(1)[1].item() # choose action corresponding to the maximum q value\n",
    "        return action\n",
    "    def update(self):\n",
    "        if len(self.memory) < self.batch_size: # 当经验回放中不满足一个批量时，不更新策略\n",
    "            return\n",
    "        # 从经验回放中随机采样一个批量的转移(transition)\n",
    "        state_batch, action_batch, reward_batch, next_state_batch, done_batch = self.memory.sample(\n",
    "            self.batch_size)\n",
    "        # 将数据转换为tensor\n",
    "        state_batch = torch.tensor(np.array(state_batch), device=self.device, dtype=torch.float)\n",
    "        action_batch = torch.tensor(action_batch, device=self.device).unsqueeze(1)  \n",
    "        reward_batch = torch.tensor(reward_batch, device=self.device, dtype=torch.float).unsqueeze(1)    \n",
    "        next_state_batch = torch.tensor(np.array(next_state_batch), device=self.device, dtype=torch.float)\n",
    "        done_batch = torch.tensor(np.float32(done_batch), device=self.device).unsqueeze(1)\n",
    "        q_value_batch = self.policy_net(state_batch).gather(dim=1, index=action_batch) # 实际的Q值\n",
    "        next_q_value_batch = self.policy_net(next_state_batch) # 下一个状态对应的实际策略网络Q值\n",
    "        next_target_value_batch = self.target_net(next_state_batch) # 下一个状态对应的目标网络Q值\n",
    "        # 将策略网络Q值最大的动作对应的目标网络Q值作为期望的Q值\n",
    "        next_target_q_value_batch = next_target_value_batch.gather(1, torch.max(next_q_value_batch, 1)[1].unsqueeze(1))\n",
    "        expected_q_value_batch = reward_batch + self.gamma * next_target_q_value_batch* (1-done_batch) # 期望的Q值\n",
    "        # 计算损失\n",
    "        loss = nn.MSELoss()(q_value_batch, expected_q_value_batch)\n",
    "        # 优化更新模型\n",
    "        self.optimizer.zero_grad()  \n",
    "        loss.backward()\n",
    "        # clip防止梯度爆炸\n",
    "        for param in self.policy_net.parameters():  \n",
    "            param.grad.data.clamp_(-1, 1)\n",
    "        self.optimizer.step() \n",
    "        # 每隔一段时间，将策略网络的参数复制到目标网络\n",
    "        self.update_cnt += 1\n",
    "        if self.update_cnt % self.target_update == 0: # 每隔一段时间，将策略网络的参数复制到目标网络\n",
    "            self.target_net.load_state_dict(self.policy_net.state_dict())   "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. 定义训练和测试"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-31T09:26:03.596050300Z",
     "start_time": "2024-07-31T09:26:03.467946600Z"
    }
   },
   "outputs": [],
   "source": [
    "import gymnasium as gym\n",
    "\n",
    "def train(cfg):\n",
    "    ''' 训练\n",
    "    '''\n",
    "    env = gym.make(cfg.env_id)\n",
    "    setattr(cfg, \"action_space\", env.action_space)\n",
    "    setattr(cfg, \"state_dim\", env.observation_space.shape[0])\n",
    "    setattr(cfg, \"action_dim\", env.action_space.n)\n",
    "    policy = Policy(cfg)\n",
    "    rewards = []  # 记录所有回合的奖励\n",
    "    frames = []\n",
    "    for i_ep in range(cfg.train_eps):\n",
    "        ep_reward = 0  # 记录一回合内的奖励\n",
    "        ep_step = 0\n",
    "        state, info = env.reset(seed = cfg.seed)  # 重置环境，返回初始状态\n",
    "        for _ in range(cfg.max_steps):\n",
    "            ep_step += 1\n",
    "            action = policy.sample_action(state)  # 选择动作\n",
    "            next_state, reward, done, truncated, info = env.step(action)  # 更新环境，返回transition\n",
    "            policy.memory.push((state, action, reward,next_state, done))  # 保存transition\n",
    "            state = next_state  # 更新下一个状态\n",
    "            policy.update()  # 更新智能体\n",
    "            ep_reward += reward  # 累加奖励\n",
    "            if done:\n",
    "                break\n",
    "        frames.append(i_ep)\n",
    "        rewards.append(ep_reward)\n",
    "        if (i_ep + 1) % 10 == 0:\n",
    "            print(f\"回合：{i_ep+1}/{cfg.train_eps}，奖励：{ep_reward:.2f}，Epislon：{policy.epsilon:.3f}\")\n",
    "    env.close()\n",
    "    return {'rewards':rewards, 'frames':frames}\n",
    "\n",
    "def test(cfg, env, agent):\n",
    "    print(\"开始测试！\")\n",
    "    rewards = []  # 记录所有回合的奖励\n",
    "    steps = []\n",
    "    for i_ep in range(cfg.test_eps):\n",
    "        ep_reward = 0  # 记录一回合内的奖励\n",
    "        ep_step = 0\n",
    "        state, info = env.reset(seed = cfg.seed)  # 重置环境，返回初始状态\n",
    "        for _ in range(cfg.max_steps):\n",
    "            ep_step+=1\n",
    "            action = agent.predict_action(state)  # 选择动作\n",
    "            next_state, reward, done, truncated , info = env.step(action)  # 更新环境，返回transition\n",
    "            state = next_state  # 更新下一个状态\n",
    "            ep_reward += reward  # 累加奖励\n",
    "            if done:\n",
    "                break\n",
    "        steps.append(ep_step)\n",
    "        rewards.append(ep_reward)\n",
    "        print(f\"回合：{i_ep+1}/{cfg.test_eps}，奖励：{ep_reward:.2f}\")\n",
    "    print(\"完成测试\")\n",
    "    env.close()\n",
    "    return {'rewards':rewards}"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.定义环境"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-31T09:26:28.763382800Z",
     "start_time": "2024-07-31T09:26:28.743462700Z"
    }
   },
   "outputs": [],
   "source": [
    "import gymnasium as gym\n",
    "import os\n",
    "def all_seed(env,seed = 1):\n",
    "    ''' 万能的seed函数\n",
    "    '''\n",
    "    if seed == 0: # 不设置seed\n",
    "        return \n",
    "    np.random.seed(seed)\n",
    "    random.seed(seed)\n",
    "    torch.manual_seed(seed) # config for CPU\n",
    "    torch.cuda.manual_seed(seed) # config for GPU\n",
    "    os.environ['PYTHONHASHSEED'] = str(seed) # config for python scripts\n",
    "    # config for cudnn\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.enabled = False\n",
    "def env_agent_config(cfg):\n",
    "    env = gym.make(cfg.env_name) # 创建环境\n",
    "    all_seed(env,seed=cfg.seed)\n",
    "    n_states = env.observation_space.shape[0]\n",
    "    n_actions = env.action_space.n\n",
    "    print(f\"状态空间维度：{n_states}，动作空间维度：{n_actions}\")\n",
    "    # 更新n_states和n_actions到cfg参数中\n",
    "    setattr(cfg, 'n_states', n_states)\n",
    "    setattr(cfg, 'n_actions', n_actions) \n",
    "    agent = Policy(cfg)\n",
    "    return env,agent"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 设置参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-31T09:31:27.300935500Z",
     "start_time": "2024-07-31T09:31:27.295935400Z"
    }
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "class Config:\n",
    "    def __init__(self):\n",
    "        self.algo_name = 'DoubleDQN' # 算法名称\n",
    "        self.env_id = 'Acrobot-v1' # 环境名称\n",
    "        self.mode = 'train'\n",
    "        self.seed = 1 # 随机种子\n",
    "        self.train_eps = 100 # 训练回合数\n",
    "        self.max_steps = 200 # 每回合最大步数\n",
    "        self.gamma = 0.99 # 折扣因子\n",
    "        self.lr = 0.0001 # 学习率\n",
    "        self.epsilon_start = 0.95 # epsilon初始值\n",
    "        self.epsilon_end = 0.01 # epsilon最终值\n",
    "        self.epsilon_decay = 500 # epsilon衰减率\n",
    "        self.buffer_size = 10000 # ReplayBuffer容量\n",
    "        self.batch_size = 64 # ReplayBuffer中批次大小\n",
    "        self.target_update = 100 # 目标网络更新频率\n",
    "        self.hidden_dim = 256 # 神经网络隐藏层维度\n",
    "        self.device = 'cpu' if not torch.cuda.is_available() else 'cuda' # 设备选择\n",
    "\n",
    "\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.开始训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-31T09:32:35.581032Z",
     "start_time": "2024-07-31T09:31:28.989294700Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hyperparameters:\n",
      "================================================================================\n",
      "        Name        \t       Value        \t        Type        \n",
      "     algo_name      \t     DoubleDQN      \t   <class 'str'>    \n",
      "       env_id       \t     Acrobot-v1     \t   <class 'str'>    \n",
      "        mode        \t       train        \t   <class 'str'>    \n",
      "        seed        \t         1          \t   <class 'int'>    \n",
      "     train_eps      \t        100         \t   <class 'int'>    \n",
      "     max_steps      \t        200         \t   <class 'int'>    \n",
      "       gamma        \t        0.99        \t  <class 'float'>   \n",
      "         lr         \t       0.0001       \t  <class 'float'>   \n",
      "   epsilon_start    \t        0.95        \t  <class 'float'>   \n",
      "    epsilon_end     \t        0.01        \t  <class 'float'>   \n",
      "   epsilon_decay    \t        500         \t   <class 'int'>    \n",
      "    buffer_size     \t       10000        \t   <class 'int'>    \n",
      "     batch_size     \t         64         \t   <class 'int'>    \n",
      "   target_update    \t        100         \t   <class 'int'>    \n",
      "     hidden_dim     \t        256         \t   <class 'int'>    \n",
      "       device       \t        cpu         \t   <class 'str'>    \n",
      "================================================================================\n",
      "回合：10/100，奖励：-200.00，Epislon：0.035\n",
      "回合：20/100，奖励：-134.00，Epislon：0.011\n",
      "回合：30/100，奖励：-192.00，Epislon：0.010\n",
      "回合：40/100，奖励：-94.00，Epislon：0.010\n",
      "回合：50/100，奖励：-122.00，Epislon：0.010\n",
      "回合：60/100，奖励：-87.00，Epislon：0.010\n",
      "回合：70/100，奖励：-134.00，Epislon：0.010\n",
      "回合：80/100，奖励：-97.00，Epislon：0.010\n",
      "回合：90/100，奖励：-73.00，Epislon：0.010\n",
      "回合：100/100，奖励：-82.00，Epislon：0.010\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjMAAAHJCAYAAABws7ggAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAADyT0lEQVR4nOydd5gUVdbG3wodJ8/AJHKQnJMgiIiIiArKmlZlUXF1VQyon4vioq4YUVRUVl0TugYMqCiIWRAFySKgIJmBSUwOnSp8f3Tf6uru6u7qNNMzc3/P4yPTXV1163Z13VPnvOccRpZlGRQKhUKhUCgtFLa5B0ChUCgUCoUSC9SYoVAoFAqF0qKhxgyFQqFQKJQWDTVmKBQKhUKhtGioMUOhUCgUCqVFQ40ZCoVCoVAoLRpqzFAoFAqFQmnRUGOGQqFQKBRKi4YaM60cWhORQqFQmgZ6v20+qDHTivn222/xz3/+My77WrFiBXr37o2ioqKEfobStnjjjTcwduxYDBo0CEuXLtXcpnfv3j7/9evXD6eeeiquvfZafP/99wkb27x58zBx4sSQ2zz33HPo3bt3RPslvwv1fwMHDsTEiRPxr3/9CyUlJZqfq6iowNNPP43zzjsPQ4YMwZgxYzBr1iysXr066DEWLlwY9bhLSkpw5ZVXYuDAgRgzZgxsNltE56mX999/H71798Y//vGPhOw/FPG8R8Xzfqvmsccew8yZM+O+39YG39wDoCSON954I277mjBhApYvX47c3NyEfobSdqivr8fjjz+OCRMm4Nprr0XHjh2DbnvxxRfjkksuAQC4XC6Ul5fjo48+wj/+8Q/Mnz8ff/vb35pq2HHj+eefR/v27QEANpsNf/75J15++WV88803WL58OTp37qxsu2fPHtxwww3gOA6zZs1Cv379UFdXh2+//RZ33nknvvzySzz55JMwGAw+x3j77bcxZcoUjBgxIuLxLVu2DDt27MCiRYuQl5cHi8US2wkH4aOPPkKvXr2wbt06FBcXo6CgICHHSTTxvN8SXnvtNbz++usYNWpU3Pfd2qDGDEUX2dnZyM7OTvhnKG2HmpoaSJKESZMmYeTIkSG3zc/Px5AhQ3xemzp1Km655RY88cQTmDhxYkhjKBnp27evz5jHjBmDiRMnYsaMGbj//vvx+uuvAwAaGxtx2223ITs7G2+++SYyMjKUz0yaNAlnnnkmbrnlFnTr1g233367zzFSU1Nx7733YuXKlTCbzRGNr7q6Grm5uZg6dWr0JxmGAwcOYMeOHXjllVcwd+5cLF++POAc2iLHjh3D448/ju+++w5paWnNPZwWAQ0ztVJmzpyJTZs2YdOmTejduzd++eUX/PLLL+jduzfee+89nHnmmRg2bBh++uknAMAHH3yAGTNmYMiQIRg0aBCmT5+OL774Qtmfvzt23rx5uPrqq/HRRx/hnHPOwYABAzB9+nSsW7cups8AwPbt23HllVdiyJAhmDBhApYtW4arr74a8+bNC3nOO3bswLXXXothw4Zh9OjRuOOOO1BaWqo5FsLEiRN99tu7d288//zzmDFjBgYNGoTnn38effv2xf/+9z+fz1VWVqJ///7K05gkSXj55Zdx9tlnY8CAATjnnHPw1ltvhf2e6urq8Oijj2LSpEkYOHAgzj//fHz44YcBY1yyZAkef/xxnHbaaRg0aBBmz56Nw4cPh9y30+nEM888g7POOguDBg3C+eefj48//lh5f+bMmZg3bx5efPFFnHbaaRg+fDhuuukmHD9+XNlGK9RSVFSE3r17Y8WKFSGP/9NPP+GKK67A8OHDceqpp+LOO+9EcXExAPf3QfZ77733RhyqIcydOxcul8tnzvTMae/evfHcc8/5vBYs9LJ8+XJMmDABgwYNwqxZs7Bnz56QY/rmm28wY8YMDBw4EGPHjsXChQvR2Nio63w6duyIyy67DD///DOOHj0KAPj8889x9OhRPPDAAz6GDGHy5MmYOnUq3njjDTQ0NPi8989//hNHjx7F4sWLdR2fMHHiRKxYsQInTpzwmauysjLcc889OOOMMzBo0CBcfPHF+Pbbb30+q/UbCsZHH32EjIwMjB49Gueccw4+/PBDCIIQsF2o33ao+1qoa1DNtm3bcOGFF2LAgAE4//zzA0J34a4prfutFi+++CIGDBiAmpoan9ffeOMN9O/fHxUVFQCARx99FEeOHMGyZcvQt2/foPNH8UKNmVbK/fffj379+qFfv35Yvnw5+vfvr7z3/PPP45///CcWLFiAoUOH4u2338aCBQswadIkvPTSS3jyySdhNBpx1113BY3fA8CuXbvw6quv4tZbb8ULL7wAjuNwyy23BPxQI/nMgQMHcPXVVwMAFi9ejFtuuQUvv/wytm7dGvJ89+zZg6uuugoOhwNPPPEEHnzwQezatQuzZ8/WvDmG4sUXX8QFF1yAJUuW4JxzzsGoUaOwatUqn23WrFkDWZZx3nnnAQAeeOABLFmyBNOmTcOLL76IKVOm4JFHHsELL7wQ9Dh2ux1XXHEFPvvsM1x33XVYunQphg8fjvnz5+PFF1/02fbNN9/EwYMH8eijj2LhwoXYtWtX2Pj8XXfdhddffx2XXHIJXnrpJYwbNw7z5s3D559/rmzz7bffYsWKFbjvvvvw4IMP4vfff8fMmTNj1kd88sknuPbaa1FQUIDFixfjnnvuwfbt23HZZZehoqICEyZMUBa5G2+8EcuXL4/qON27d0dhYaFyfUQyp3ooKSnB888/j9tvvx2LFy9GTU0NZs6ciRMnTmhu/9lnn+Hmm29G9+7d8cILL2DOnDlYuXIlbrrpJt3i0LFjxwKAck7fffcd2rVrh6FDhwb9zHnnnQebzaYs4oTRo0fjsssuw1tvvRX2N6Tm+eefxxlnnIH27dtj+fLluOSSS3Dy5ElcfPHF2LJlC+bOnYvnnnsOHTp0wM0334yVK1f6fN7/N6SFIAhYuXIlzj//fBgMBlx00UUoLy/Hd99957Od3t+2/30t3DWoZsGCBTj33HOxdOlSnHLKKZg7dy6++eYbAPquqVD3WzUXXHABBEHAV1995fP6qlWrMG7cOOTk5AAAbr/9dqxcuTKsx5LihYaZWik9e/ZEamoqAAS456+44gpMmTJF+fvYsWOYPXs2brrpJuW1Dh06YMaMGdi6dauyYPtTV1eHFStWKLF9q9WKq666Chs3bgx6Awv3mZdeeglpaWl45ZVXlBh99+7dcfnll4c83xdffBGZmZl47bXXYDKZAAC5ubm488478eeff4b8rD8jRozANddco/w9ffp03HvvvThx4gQKCwsBuG8+p512Gtq3b49Dhw7h/fffxx133IHrr78eADBu3DgwDIOXXnoJV1xxBbKysgKOs2LFCuzbtw/vvfeeslCdfvrpEAQBS5cuxeWXX47MzEwAQHp6OpYuXQqO4wAAR48exXPPPYeqqirNfe/btw9ffvkl7r33XsyaNQuAO4xx/Phx/PLLLzj//PMBuLUaK1asQKdOnQC45/qiiy7CJ598gr/+9a8RzRtBkiQ8+eSTGDduHJ566inl9WHDhmHq1Kl49dVXcffddytPnJ07dw64RiOhXbt2OHnyJIDI5lQPoijihRdewKBBgwAAgwcPxqRJk/DWW28FGJOyLOPJJ5/E6aefjieffFJ5vWvXrrj66quxdu1aTJgwIewxiY6mvLwcAHD8+HF06NAh5GfI70ntVSPcfffd+PHHH3Hvvffi008/1RVu6tevH7Kzs2E0GpXvZtGiRaisrMSXX36pjOeMM87A1VdfjSeeeALnn38+WNb9fOz/G9Ji3bp1KC8vx4wZM5TPdO3aFe+99x4mT56sbKf3t62+r+m9Bgm33HILZs+eDQAYP348Dh8+jKVLl2LSpEm6rqlQ91s1HTp0wMiRI/H5558rGrCjR49i586dePrpp5XtevXqFXLuKIFQz0wbxN9tOW/ePNx1112ora3Fjh078Omnn+Ltt98G4A5VBCM7O9tHpJifnw8AIZ/qw31m48aNGD9+vI/YcOjQoWFv5lu3bsX48eOVmx353HfffRexm9Z/+8mTJ8NkMimu5+LiYmzduhXTp09XxizLMiZOnAhBEJT/Jk6cCIfDEfSJeNOmTejQoUPAE/e0adPgcDjw66+/Kq8NHDhQMWSA8HNNjqleFAB3KOWhhx5S/h42bJhiyADuRaxTp07YvHmz5n71cOjQIZSXlysGE6Fz584YOnQoNm3aFPW+tZBlGQzDAIhsTvXQqVMnxZAB3IbGkCFDNOfn4MGDKCkpCbgORo4cidTU1ACvSajzAaCckx6IESGKYsB7KSkpePjhh3H48GGfBTNSNm3apPlbnDZtGsrLy3Hw4EHlNT2/uY8++gjdunVD586dUVtbi9raWkyZMsUnxAbo/22r/x3pNeivC5o0aRL27NmDhoaGqK8pURR9rgNJkpTPbd68WTFWV61ahdTU1LCZc5TQUM9MG8Rqtfr8ffToUSxYsAAbNmyAwWBA9+7d0adPHwCh6yb4ZzeQmy/50UbzmcrKSsXVqqZdu3ZB9wm4xYpan4sG//lJTU3FpEmTsGrVKlx33XVYvXo1LBYLJk2apBwbQFAPFont+1NTU6M8hash51pbW6u85j9vZPEKNtdkTOHmJC8vL+C1nJyckKHCcJBja31n7dq1C6s5iZSSkhLlSTaSOdWD1jnk5ORo6i7IeT/44IN48MEHA94vKyvTdUwS2iUGa4cOHbBz586Qnzl27BgAKJ5Df8aMGYPLLrsMb775ZlCvaThqamp8DF+C1tz6/4b8qaiowNq1a+FyuTRDKcuXL8f//d//AdD/21YfM9Jr0H+7nJwcyLKM+vr6qK+ps88+28dTdtFFF+Gxxx7DlClT8NBDD+GLL77A3/72N6xatQrnnHNOxAJtii/UmGnjSJKE66+/HgaDAR9++CH69u0Lnuexf/9+fPrpp00+nvz8fCVkoKaiogLdu3cP+rm0tDRUVlYGvL527Vr07ds3qKHlL5gMxrRp03D99dfjyJEjys2HGBjp6ekA3KmsKSkpAZ8NtsBkZGTgyJEjAa+TJzat8JFeyJgqKyuVRRFwa5Kqq6sxfPhwAEBVVVXAZ0+ePKl4zxiGCXjaDydmJWEcre+xvLw8pvPyZ//+/SgvL8eVV14JILI51XNeWkZdeXm5ZpYemfO7775bM5VWS7yrxc8//wyGYZR06okTJ+L777/Hli1bfFKs9+zZgz59+oBlWXz11VcwGAwYPXp00P2ScNM999yjGOKRkJGRocyjmmiu15UrV0IQBLzwwgsB2TrPPfccVqxYgdtuuw1GozHsb1uLSK/BmpoaH4Pm5MmT4DgOGRkZUf9O//Of//h4tsl2aWlpmDhxIr744guMHj0af/75J/71r39p7oOiHxpmasWQp/dQVFVV4dChQ7j44osxcOBA8LzbviUZRqG8LIlg5MiR+PHHH+FwOJTX9uzZE7ao1YgRI/DTTz/53Dz27NmD66+/Hrt371bi2WpBM1nY9TBu3Di0a9cOb775Jnbv3q2EmMixAfdcDhw4UPmvsrISzz77bNBjjBw5EsePH8f27dt9Xl+5ciUMBoNPeCNSiLHiL6Z88skn8fDDDyt/b9261ceg2bVrF4qKijBmzBgA7hBFVVWVz/cRTkjarVs3tG/f3kdoDLi9Bzt27MCwYcOiOykNlixZArPZjIsuugiA/jlNTU0N8Jht27YtYP+HDh3yCXkUFxdj+/btOPXUUwO27d69O3JyclBUVORzHeTl5eGpp57S5ZEqKSnBBx98gAkTJij1Vi644AJ07doVDz74oHItORwOzJo1C+effz5ee+01fPrpp7jqqqtClkJITU3FwoULcfjw4agE1yNHjsT27dsDdDkrV65E+/bt0aVLF937WrFiBYYMGYJJkybh1FNP9fnv0ksvRWVlJb7++msA4X/bWkR6Df7www/KvyVJwpo1azB48GCYzWbd15T//ZYUQyT/qdPwp0+fjh07duDdd99FYWEhrSMTB6hnphWTnp6O7du3Y8OGDejXr5/mNjk5OejQoQPefvtt5OfnIz09HT/++CPefPNNAKH1L4ngH//4B1avXo3rrrsO1157LWpra/Hss8+CZdmQGoKbbroJl112GW644Qb87W9/g91uxzPPPINBgwZh7NixsNvtMJvNeOyxx3DbbbehoaEBS5Ys0S0G5TgO5513Hv73v/8hLy/PZzHr3bs3pk2bhn/96184fvw4BgwYgEOHDuHpp59Gx44d0bVrV819zpgxA++88w5uvvlm3HrrrejYsSO+++47fPTRR5gzZ47ypB8Nffr0wZQpU7Bo0SLY7Xb07dsX69atw/fff++TKmuz2XDdddfhxhtvRENDA55++mn06tVL0RqceeaZeOuttzB//nxcfPHF2LdvH15//XUf/Y4/LMvijjvuwD333IM777wT06ZNQ1VVFZ5//nlkZGSEFYZqUVJSgh07dgBwZ8GUlpbi448/xvr16/Hvf/9b8T7pndMJEyZg1apVGDx4MLp06YIVK1ZoPn2bTCbceOONmDt3LkRRxLPPPovMzExFVK2G4zjMnTsXCxYsAMdxOPPMM1FbW4ulS5eitLQ0IMPl999/VzwHNpsNe/fuxRtvvAGz2YwFCxYo21ksFixZsgQ33HADLrzwQlx99dXo168f7r//fjz00EN4/PHHkZWVpauC7tixY3HJJZfggw8+0DfxKq655hqsXLkSV199NebMmYPMzEx88skn2LhxIx555BFdD08AsHPnTuzbty+oN+Lss89GSkoK3nvvPZx33nlhf9v+RgYQ+TX4zDPPQBRFFBQU4N1338WhQ4eUOj96ryn/+20oT9zpp5+OzMxMLF++HNddd11E+iiKNtSYacVceeWV2LVrF/7+97/j0UcfDVqJd+nSpXj44Ycxb948GI1G9OzZE//5z3/wyCOPYMuWLU1aSrtLly549dVX8cQTT+DWW29FTk4ObrjhBvznP//RDOEQ+vXrh7feegtPPfUUbr/9dqSmpuKMM87AXXfdBaPRCKPRiOeeew5PPfUUbr75ZnTo0AFz5szBJ598onts06dPx7Jly3yyNgiPPvooXnrpJbz33nsoKSlBTk4Opk6dittvvz3owm+xWJQxP/vss6ivr0f37t3x8MMP4+KLL9Y9rmAsWrQIzz//PJYtW4aqqir06NEDS5Ys8QkxjBgxAqNHj8b8+fMBuEMad999N4xGIwD34vfPf/4Tb731Fr788kv0798fzz//fNjsshkzZiAlJQUvvfQSbr75ZqSmpuL000/HHXfcoak/CMeHH36o1PVgWRaZmZkYPHgwXn/9dcWLBOif03vuuQeCIODxxx8Hz/OYOnUq7rzzTtx3330+x+3Xrx/OOeccPPDAA6irq8OYMWNw7733BvWAXHLJJUhJScErr7yC5cuXw2q1YtiwYXjyyScD9CZz5sxR/m0wGNChQwecffbZuP766wPmiNT1efPNN/HBBx/g+PHjMJlM6NWrl1IT5oILLsC8efOCarcI8+bNw/r16zV1P6Fo37493n33XTz11FNYuHAhXC4X+vTpg6VLl+Kss87SvZ+PPvoIHMf5ZFSqsVgsOOecc7BixQocOHAg7G87GJFcg48++igee+wxHDlyBL169cJ///tfxVui95ryv99ecMEFQcfG8zzOO+88vPXWW5g2bZruuaMEh5FpZyxKEkFEyGptQG1tLU477TTcfffdLbJsfbJCjFQ9xf0oyY3T6cQnn3yC3NxcXenfFEprg3pmKEnF7t27sWTJEtxxxx3o378/qqur8frrryMtLS0gzZJCobgxGo249NJLm3sYFEqzQY0ZSlJx7bXXwul04t1330VxcTGsVitGjRqFRx99lPZ5olAoFIomNMxEoVAoFAqlRUNTsykUCoVCobRoqDFDoVAoFAqlRUONGQqFQqFQKC0aasxQKBQKhUJp0bSZbCZZliFJ8dc6syyTkP1SAqFz3XTQuW5a6Hw3HXSum454zDXLMroqJLcZY0aSZFRW6msqqBeeZ5GVlYLa2kYIQtP2MGpr0LluOuhcNy10vpsOOtdNR7zmOjs7BRwX3pihYSYKhUKhUCgtGmrMUCgUCoVCadFQY4ZCoVAoFEqLhhozFAqFQqFQWjRtRgCsB0mSIIpCBNszsNs5OJ0OiCJVxycSOtf64DgeLEufUSgUStuCGjNwp23X1lbCZquP+LMnT7KQJKqKbwroXOvDYklFenq2rnRGCoVCaQ1QYwZQDJnU1CwYjaaIFgGOY6inoImgcx0aWZbhdDpQX18FAMjIyGnmEVEoFErT0OaNGUkSFUMmNTU94s/zPEvrFTQRdK7DYzSaAAD19VVIS8uiIScKhdImaPN3OlEUAXgXAQqlpUOu5Uj0XxQKhdKSafPGDIHqCyitBXotUyiUtgY1ZigUCoVCobRoqDFDoVAoFAqlRUONGUqzMGfO9Xj44QeaexgUCoVCaQVQY4ZCoVAoFIouGuwufLr+EEqrGpt7KD5QY4ZCoVAoFIoufv6tBJ+uP4SV6w8191B8aPN1ZoIhyzKcrvA1TURJTkjtE6OBjTgrZdy4Ebjmmr9j9erPIAguPP/8f5GfX4D//vc/+OqrL9DQUI9u3Xrguuv+gVGjRuPAgf2YNetyvPrq/9C7dx8AwD333IVt2zZj9ervwHEcJEnCtGmTccstd+Ccc6bis88+wYcfvodjx46BZRn06tUHt956B/r06QcAuPjiCzBhwlnYuPEnVFVVYuHCJ9C//0C8+OJz+OqrNXC5nJg+/S+QZd/id++88xY++eRDlJeXoV279jjvvGmYNWs2zcyhUCiUJKKq3gEAOHEyuTwz1JjRQJZlPPq/bdh/vKbZxtCzYwbuuXJYxIv5xx9/gCefXAJBENGpU2c88MB8HDlyCAsWPIT27XPx00/rcPfdt+ORR57EaaeNQ0FBITZv3ojevftAFEVs374FjY2N2LfvD/Tt2x979uxGXV0dxowZh7Vrv8fTTz+Bf/7zPgwePBQnT57EM88swmOPLcQbb7yjjGHFivfx+ONPIy0tDd2798QzzyzCTz/9iPnz70deXgHefPM1/PrrdhQWdgAArF+/Dm+99Tr+/e9H0KlTV+zevRMLF96PgoJCnHPO1LjOK4VCoVCip77RBQAoqWqELMtJ88BJjZlgJMf3EzHnnDNV8ZIUFR3DN998iddffxunnNIbAHD55Vdh//4/8c47b+K008Zh7NjTsXnzL7jqqqvx+++7wfMGDBgwENu2bUHfvv2xYcN6DB48FOnp6cjIyMC8ef/C5MnnAgDy8wtw/vnTsHjxEz5jGD16LEaOPBUA0NjYgC+++Bx33vlPjBkzDgBwzz0LsG3bFmX7EyeKYDQakJ9fiPz8fOTn56Ndu1zk5eUnfL4oFAqFop+6RicAwOEUUdvgREZqchScpcaMBgzD4J4rh+kKMyWqxH40YSYA6Nixs/Lvffv2AgBuuuk6n20EQUBqahoAYOzY07Fy5cdwOOzYvPkXDB8+Avn5hdi6dQuuvHIWNmxYjylTzgcADBkyDIcPH8Ibb7yCI0cOo6joKA4c2B/Q/LFjx07Kv48ePQKXy4U+fforr5lMJvTq1Vv5e/LkqVi1aiX++tcZ6Nq1O0aOPBUTJpyF/HxqzFAoFEoyUWdzKf8uqWykxkyywzAMTEYu7HY8z4Jjk8eNYzJ5LyxZdhsZL7zwX1itKT7bkZ49Q4eOgMFgwPbt27Blyyacc85UFBQUYMWK91FSUow//9yHhx8+AwDw1Vdr8PDD92Py5HMxYMAgTJ8+AwcPHsDixY8HHQNxcZGxEHjee+llZmbi9dffwa5dO7F58y/45ZcN+OCDdzF79g245pq/xzYhFAqFQokbJMwEAKVVNvTunNWMo/FCs5laMd269QAAVFScRMeOnZT/Vq1aidWrPwPgNipGjRqD9evXYs+eXRg+fCQGDRoCURTx6qsvoXv3nigoKAQAvP32G7jgggsxf/4D+MtfLsWQIcNw/HgRAAQIegmdO3eB0WjCzp2/Kq8JgoA//9yn/P3VV1/g448/xKBBQzB79g14+WX3cb799quEzAuFQqFQoqPO5lT+XVqZPCJg6plpxXTv3gOnnXY6Fi16FHfc8U9069YdP/zwLf73vzdw7733K9uNGzcejz++EO3atUeHDh0BAAMGDMKXX67G3/52rbJdbm4efvvtV+zd+wdSU1Oxfv1arFjxPgDA6XT6eWTcWK1WXHzxpXjttZfQrl07dO3aHe+++xZOnixXtnE6HXjhhWeRkpKCwYOHoqysDNu3b8OQIUMTNTUUCoXS7Lz//X78uv+kz2sGjsUlZ/ZE/27ZzTSq4AiiBJtDVP4urbI142h8ocZMK+ff/34UL7/8AhYtegR1dbUoLOyIefP+hXPPPV/ZZsyYsRBFEcOGjVBeGzFiFLZt24Jx485QXps792488cTDmDPnehiNBvTs2Qv33fcg7r//Xvzxxx4MHqxtfNxwwxwYjSYsXvw4GhsbMXHi2Rg7drzy/vnnX4iamhq88cYrKCsrRVpaGiZMOAs33nhrAmaEQqFQmh+7U8CaX45qvvfjzhNJaczUqUJMQHJ5Zhg5WHyglSGKEiorGwJed7mcqKgoRk5OAQwGY8T7TZQAmBIInWt9xOOazspKQVVVA53vJoDOd9PhP9c2h4BGu4CcDHPQzwiihMpaO3KzrHEdy9HSOjzw+makmHnMmTEQAPDr/gqs2XQUQ3q2w60XD4rr8eLBsbJ63P/aJjAAZAA8x+LFu84Aq5GsEq/rOjs7BRwXXhFDNTMUCoVCaZM8+8Gv+OeLG7B9X7nm+zaHgIVvbsG8lzbiSEldXI9dXm0HAORmWdG7cxZ6d85Cp9xUAIBTEEN9tNkgadl52VZwLKMYeskANWYoFAqF0uaQJBkHTtRCkmW8tHI3DvgVSRVECUs//g1HS+sBAMdP1sf1+OXVbr1J+0yvV8jAu5dkZ5J66Oo9adnpKUbkZlkAAKWVyaGbocYMhUKhUFo05dU2vP31PsVA0ENlnR2i5FZZOAUJz364U2meKMsyln3xB3YfrlK2Vwtf40GZZ6zEKAAAo8FdDsTp0n8sSZLx468n8NZXe1GSYA0L0cykWQ3I84TdkqXhJBUAUygUCqVF88P24/h2axEMPItLz+yp6zPlnkycnHQz0qwGHC6pw9PLf8W9fxuO77YW4addJWAZBvk5Vpw42YBGuyvMHiOj3GMEtM9UGTMez4xLp2fm98OVeO+7/ThW5vYardtxAhOHdcS0cV2RYjbEdbyAN8yUZjEoddgSbUDphRozFAqF0owIYnKGFFoSxGNQ42mCqIfyGrfWo7BdCq49ry8efnMLyqpteOiNLajw6EBmntMLJZWNOHGyIe6eGUUzk6nlmQl9TZRUNuL97/Zjhyet22ri0TkvFX8crcbXW47h513FmD6uGyYM7QA+hHhW8nimWJ2FX0n131SrEdnp7lIcNMxEoVAobZwtf5Th+ie+x9ptRc09lBZNo0MA4FtqPxxlVV7NSkaKEXMvHYwUM68YMhec1hVnDOkAi4n3HCN+nhlRkpTjaHlmQgmAi8rrseDVX7Bj/0mwDIOzhnfEY/8Yg7uvGIY7LhuMDu1S0GAX8M43f+L+1zbh1/0nA4qaCqKErzcfw21LfsQT72zTPW5S/TfNQsNMFAqFQvGwY/9JCKKM3YcqMKhbcpSFb4mQEJB/HZRQKJoVjzFRkJOC2y4ejJc/242hp7THhad3A+D2eriPIcRtvBW1DoiSDJ5jkZnmLTZqMIQXABeV1UMQZbTPNOO2iwejsJ23Vc2Abjnoe20W1v1ajI/XHURxRSOe/XAn+nfLxuUTe6KwXQp+PVCB5d/tV2rE7CuqgShJ4Njwvg0lzGQ1ID/bbcycrLZDEKWQHqCmgBozFAqF0kwUV7hrX9kd8Vso2yLEM1MfgTFDNDPtVQLcnh0z8MSNp/lsZzW7l0lbHL8jdSaTukaLkfcKgGVZ1mw2TAydDu1SfQwZAseyOHNoB5zaNw+fbziMrzcfw+5DlVjw2iZ0ap+Kox59TbrVgFrPfDXaBaRZw9ekqlfCTAZkphphNLBwuiScrLErxk1zQcNMFAqF0gzIsoziCvfTsd2ZnHVFWgrEa6LuGxQOr0FhCbmdN8wUR2OmSvvYRo9nRpahZFr54/BkOpFtg2E187j0zJ54+O+nYniv9pBl4GhZPXiOwbmjO+PRG8bA7BHx6vU6KdlMFiMYhlFCTckgAqaeGQqFQmkGquocihETz6f+tgiZP6dLgsMlwuQR0gaj3uZSjJNwxowSZoqjANg/xEUgnhnAfS5aoRunYsyEPkdCbpYVN88YiL1Hq7D7cBXGDSpQjptiNsDuFFFvdyEvzH5kWVY8M2lWd6ZUXrYVx8rqk6KtAfXMUBKKIAhYvvxt5e9XX30JF198QdyPk6j9Nget6VyaClmW8cLHv+G1Vb8391B0Q7wyADVmYkGSZR+viZ5QU5lHtJqRagxr+BDPjC2OqdnBPDM8x4AEloKJgEmmk4nXZ8wQenfOwozx3X0MqBSzfj2QzSEo3qJUi8eYIYXzkqDhJDVmKAnl66/X4Lnnnm7uYVBaObWNLmzdW471vxW3mFTnExXeXnFUMxM9DqcIdbJOvY6MJpLJ5O8Z0YJoZuLpmVFCXFm+x2cYJqwImBg54cJMeiDn1qDDUCOZYiYDp3iFiE6mzXpmGhoa8OCDD2LcuHEYMWIE/v73v+PAgQM+22zYsAEzZszA4MGDMWXKFKxatao5hkqJkTbSx5TSzKgrpopiy7jmfDwzVDMTNf4LMcm4CUVZEM+IFiTMJIgSXHHomSTLctAwE+ArAtbC4fHM6A0zhSLF42FpsIU3ptXVfwl52cmTnt0smpmHHnoIO3fuxJIlS5CRkYFFixbhuuuuw5o1a2AymXDgwAHccMMNuOaaa7Bo0SL88MMPuPvuu5GdnY0xY8Y0yRhlWQaE8D8KWWYhJ6KPBm/UVLKHYsOGn/DKKy/i8OGDsFisGDNmLG655Q6kp6dj27YtmDv3Zvz734/hxRefQ2lpKQYMGIj58x/Au+++hTVrVoHnDbjkkssxa9ZsZZ9ffPE53nvvbRw7dhTZ2dk4//zpmDnzGnCc+4dUWlqCl156AVu2bEJjYwMGDRqCm266DT17noLVqz/DI488CAAYN24Elix5Udnv//73Bj766H3U1NSgf/8BuPvu+ejUqTMAoL6+Hi+88Cx+/PF7uFwu9O7dFzfddCsGDBigfP7TT1fgnXfeRHl5OUaOHIWCgsKQczNnzvXo1KkL9u/fh2PHjuCOO/6JyZPPxapVK/HOO2+iuLgYBQUFmD79L7j44ssAANOmnYOrrpqFyy+/CgDw/vvvYsmSp/DKK2+iT59+AID58/8PaWnpmDfvX/j11+149dWX8Mcfv8PlcqKwsAP+9rdrcc45UwEADz/8AGw2Gxoa6rF79y7MmnUtrrxyVthzCfW9Utyob/yCJMGE2G/0iab4JPXMxAP/EImeWjOReGbMJl7pEt3oEJERYXjHnzqbS9FKtdPo1m00sIAteBVgp04BsB68Yabwc0bCdyTEBHjDTJW1Dl1apUTSLMbMN998g9tuuw3Dhg0DANx+++2YPn069u/fj/79+2PZsmXo3bs35s6dCwDo0aMH9uzZg1deeaVJjBlZltG48mFIpfsTfqxgcHmnwDLtXt0GTXV1NebP/z/MmTMXp502DmVlpXjoofuxdOmzmDfvXwAAURTx5puv4f77F0IQBPzf/92Oq6++AuefPx0vv7wMX331Bf773/9g3Lgz0KNHT7z//jt48cXnMWfOXIwceSr27NmFxYsfR01NDW677U40Njbgxhtno7CwAx577CkYDEa89trLmDPn73jjjXdx1llno76+HkuWPIVPP12D9PQMbN++FSUlxfjtt1+xaNGzcLmceOihBXjssYfwwgv/hSzL+L//uxVGoxmPP/4MUlNTsWbNKtx442y88soy9OjRC19/vQaLFz+O2267CyNGjMK6dd/j5ZeXIjc3tITt888/wb/+9RB69uyJnJx2+PTTFXjppRdwxx13o2/f/vjzz714+ukncPJkGW666TaMGTMWmzdvUoyZLVt+AcMw2LZtC/r06QdBELB58yYsWPAQysvLcMcdc/CXv1yGu++eD5fLhbffXobHHnsII0eeiuzsHADADz98i5tuuhVz594Nk8kU9lz0fK8U79MqAAgtxjNDjZl44K830lNrJliYRwuWYWA2cbA5RDTaXchICZ/CrOfYWWkmTe9KOM+MYszEaFQBgNXT8qBBh2bGW2PGe/6pFgNSzDwa7ALKqmxK1+/moFmMmZycHKxevRpTp05FWloaPvzwQ2RmZqJzZ/eT+ZYtWzBp0iSfz4wePRoPP/xw0Nx7PfB8oCUrSdr78sqwWgbl5aVwOp3Iy8tHfn4B8vML8PjjiyGKvj+I6677h+JVGD58JPbs2YWbbroVDMNg5syr8cYbr+Dgwf3o3r0H/ve/ZZgx41LMmHEJAKBTp86oqanB0qXPYvbsG/D112tQU1ONV1/9H7Ky3AW/HnhgIS699EKsWPE+brrpNqSmui/unJx2yhh4nseCBQ8hJcX93vTpM/Dyy0sBAFu3bsauXb9h1apvkJ6eAQC44Yab8dtvv2L58ncxf/79+PDD5Zg0abIyrquuuhq7d/+GP//cF3KOTjmlFyZPnqL8vWzZq7j66tmYNOkcAECHDh3R0NCAp556HLNn/wPjxo3HQw8tgNPpBMuy2L59G8aNOwPbtm3BFVf8DTt2bIMkiRg5chROnjyJ2bNvwF//OlO5PmfOvAZr1qzyeLXcxkxaWjquuOJvyhjCnYve71ULjmM0r/nwn2N9/t8SECXfp9hozpvw864S/HGkCrPO7a2rkFg01NtcSo0PwKOPYGIbd1vF7rfoN9pdQeeRXNPEM5OfY9U151aTATaHCKcgxfwdVdS6Wy7kZlk090U8LqIsa77v8mjCLCY+5rEQw8TmEMLui4is01MMPtvmZVtx8EQtTtbY0K3Q6y1u6vtIsxgzDz/8MO6++26cdtpp4DgOVqsVr732GtLS0gAAJSUlyM/P9/lMbm4ubDYbqqqqkJ2dHfExWZZBVlZggSG7ncPJk2zAjZ+fcZ+uMFPCiDDM1LdvX0yePAX//OdctGvXDqNGjcbYsafjjDPOBM+zygXVpUsX5TytVisKCwth8Dwd8Lw7/imKAurqalBZWYGhQ4f6zMuIESMgCAKKio7g0KED6Ny5C9q3z/EOm7eif/8BOHjwAHieVXp+kH2wLIPs7BxkZHgv+oyMDDgcDvA8i/3790KWZfzlL+f7nJ/T6YLT6QTHsTh4cD8mT57iM65Bgwbjzz/3Bf1BMgyDTp06K+9XVVWhrKwUL730Av773/8o20mSDKfTgbKyYowZcxokScKePTuV63TGjL9g/vx/ApCwceNPOPXUMUhJsSIlpTOmTZuOFSuWY//+/SgqOob9+4lx5b4p+Y8BQNhzCfe9aiFJDFiWRUaGFWZzoBtbL+np4Z9akwVjSb3y75RUs+ZvXS+f/ngIxRUNmDy6Kwb2bBf+A1FQXF0BAMhMNaHa00/IYDL6uPAp+mA4Xw+FQ5RDfv8uQURlnbuVQK+u7Xwq8AYjLcWIilo7WAMf07UFAHUeL0invHTNfRFvidFk0Hxfkt331OxMa8xjaZ/j/rwzzJwBgNPzvNA+O8Vn284F6Th4ohY1NkFzH011H4m7MVNUVISzzjor6PsbNmzA3r170alTJyxcuBBWqxX//e9/MWfOHCxfvhwFBQWw2+0wGn1deeRvpzM6A0OSZNTWBoqUnE4HJEmCKMoQ/GOUTOgbC8O4rU5RlBB3nasowx2l1c+CBQtx9dXXYePGn7F58y944IH7MGjQEDz77H8geqx5hmGV83SLc5mA85YkGYJH6OY/Ly7PUxDDcJAk93n7f14URXAcB0GQlEZmZBtJksGyrM9n1NsIgoiUlBS8+ur/fPbJMIDZbPKcBwNRFH32wbKcz3H8kWUZRqNJed/lct9QbrllLkaMODVg+7y8fBgMBgwdOgIbNmyAwWDAsGEjMGDAELhcLuzatQs//fQjZs68BoIg4dChg7jppuvQu3cfjBx5KsaPn4DMzCz8/e+zIIoSBEHyjMHoN8bw5xLqe9VCFGVIkoSamkbYbJELFjmORXq6BbW1NuW6SXYqqrwhm4rKephj8MBX17sXumPFNeiYk5gb8d5DbmOmY/sU1DU6IUoyyivq4YoxhBEpsizD5hCVrJaWSHllg8/fFdWNqKpq0NyW41jU2ATIMmA2cpBcLlRVhQ+xmDwPDmUn61GVG5sBceREDQAgw8prjpNUBK6s0j6PBk9hQJfTFfQ89cJ6PJrVdfaw+zrpmWcDC59ts1Pd1+yh49U+r8frPpKebtHl3Yn7FZyXl4fVq1cHff/QoUN46KGH8N1336Gw0C10fOaZZ3Duuefitddew/z582EymQKMFvK3xRL9zUVroYsl84EYMMmQsLN79y58++2XuPXWO9G5c1dceukV+OqrL/Dvf/8LVVWVEe8vOzsH2dk52LlzB8aPn6C8/uuv22EwGNChQ0f06HEKvvjic1RVVSIry+0tczgc+OOP3zFlynkAEHFIsHv3nmhoaIDL5UK3bt2V1x9/fCF69eqFiy66FKec0gs7d/6KSy+9Qnn/jz8iqy+SlZWNzMwsnDhxHB07dlJe//bbr7Bu3feYP98tXB479nR8/vknMJstmDr1AlgsFvTvPxCffroCJ04cx2mnnQ4A+PTTj5CdnY1nnlmq7Gv9+nVhxxHuXMJ9r2TetdA00COAGGEtAZsq5u9wilGPWxAlpTtyVZ0jYedf5Ckpn59txaHiWjTYBTTaXEg1Na1R8cXGI/hw7QH8/YJ+GN0vP/wHkhAiTCXajdp6Z8jvjaQRt8uweO7/4W/gpNZMfWPofeuhzHP8nAyz5r4MnPueaQ9yHZMKwBwb+CAaKSZPBeB6myvsvmoa3Gtwitngs237DPeaXFzRGGSNbZr7SNyDWQaDAT169Aj6344dO5CTk6MYMuQz/fr1w5EjRwAABQUFKCsr89lvWVkZrFarEoqi+JKSkoIVKz7A0qVLUFR0DAcP7se3336Fjh07IyMjM6p9/vWvM7Fixfv4+OMPUVR0DF99tQavvfYypk27CKmpqTj77CnIyMjEv/41D7//vhv79/+Jf//7PthsNkyfPgOA1/j844/f4XDYwx7z1FPH4JRTeuH+++/Btm1bUFR0DM89txirV3+mGDdXXXU11q37Hu+88yaOHTuKDz98Dz/88G1E58YwDK68chY+/HA5PvpoOY4fL8Latd/jyScfg8lkVjyBY8eejv37/8SePbswYsQoAG6t0ZdfrsaAAYOQmZkJAMjNzUNZWSk2bPgJJSXFWLv2Ozz11GMAQnsTw51LIr7X1ohPNlMMDyjq4ms1DY6YxhQKkpZd0C5FWVCao6XB3mPVkGXg3W/+1JXRkoyQbCaSJhwum4lkkeXqEP8SLCZP2f84CLW9adnavYyIKDisADgeqdkRFM1T+jL5hUKTpdZMk6vN8vPzPXoFr7EiSRL279+Prl27AnDrMjZt2uTzuY0bN2LYsGFgEyTIa+l07doNDz+8CNu2bcE111yBG2+cDZbl8NRTS6Kes7/+9SrcfPNtWL78HVx11SV45ZX/4MorZ+HWW+8EAKSmpuK5515CWlo6brvtJtx003VwOBz4z39eRWFhBwDAsGEj0a/fANx447X46af1YY/JcRyefnop+vTphwUL5mHWrMuxY8d2PPzwIsWYOO20cbj//oVYtWolZs26HGvXfq9kHEV6fnPmzMVHH72PK6+8GM8++ySmTbsId911j7JNXl4+evToidzcPOTnFwAARowYBUmSMG7cGcp2F198OSZOPBsPPbQAM2dehmXLXsX119+EgoJC/PHHnqBjCHcuifheWyO+2UzRPwU2qBbC2vrEaeZIJlNhjhUWo3tBsTu1FxSbQ8CqDYcTsliQDJW6Rhc+XX847vtvChod7u+MGCfhsplKPHOvJy2bYDW5F/BYKzU7XSKqPddV+0xtPZuRD1M0j9SZiYNYPEXJZtJRNE/VMVuNet6b0yBu8kDpmWeeiU6dOuHWW2/FPffcg9TUVLz22msoLi7G3/7mzvKYOXMmLrroIjz55JO46KKLsHbtWqxZswavvPJKUw+3RTF27OkYO/Z0zfeGDRuB9eu3+Lw2f/4DAdv5b/OXv1yGv/zlsqDH7NChIx599Mmg76enp+Pll99QvTIJs2ff4LPN1KkXYOpUb/n+zMxM3Hvv/UH3CQBnnTUZZ5012ee1G264Oej2zz//subrM2ZcomQSBeP119/x+XvgwMEB82Q0GnHPPQtwzz0+L+Pcc71CZq35BsKfS6jvleJGXfo9lvi8OkW1RkfxtWhwuERU1Li9lAU5Xs+MI4hnZvMfZfho7UEcKa3HTRcO0NwmWmobvOf47dYijB9SiA4anZiTGcUz42l62GB3ebR52iHuEo9XLJgxoYXFHFlDxmCUe753i4kLKvY2hPPMeK71eNR0IZ4Zp0uCS5BgCGEgBfPMWEw82mWYcbLGDrtTVATMTU2TP9pZrVa8+eab6NChA26++WZcfvnlKC4uxrvvvouOHTsCAE455RQsXboUa9euxYUXXogPPvgAixYtarKCeRQKpWXh8CmaF32YqSk8MyUVjZDhXkjSrAalc3GwMBPRKqiL7MUDWZaV9PAu+WmQZBnvfL2vxVXtJgYG8bTIcmhPA/GK6akxQ4iXZ0bdkymYnpB4XIIXzYtfBWBSEBAIXTjPJXi1ZOo6M4SbLhqAf0zvjywdmWGJolkk7Hl5eXjqqadCbjN+/HiMHz++iUZEoVBaMs54hZlUN/SahsQYM2QxLWiXAoZhwmpmSEG90ipbSI9DpNidorJgXndeXzz4xhb8fqQK2/aVY3jv3LgcoykgOpY0qwFWE49Gh4B6m0tz0ZVkGaVRhJkUzUyMnhmilwnVRoHUmVFf0wRBlJRmj/GoAMwyDKwe4XS9XUBGqrYxQrwyZHt/uuano2t+81Ykp0F3CoXS4olXbyZ1j5raRqdSNiCenPCEOQpz3GERs8G9ODhcwTUzgHshq6wNL6LXCwkxmYwcOrRPxZRT3UVL3/t2f9AQRzJCDAyr2YBUj54jmG6mpt4JpyCBZRhkp+sPM5HQSawC4HIdbRSUCsAafaDUBk48KgADXt1MKM8M0cukWngldTzZoMYMhUJp8ajFkvHyzMiyvg7MkaJ4ZjwFy8ym0J4ZdRPKUs9iGA9qPQtUuscAOG9MF2Snm1BRa8cXvxyN23ESDTEwrJ6wHRDcmCmr8qZF8xFUpiXNJvWGmWRZxh9HqnC0tM7n9fKa8G0UQgmAiYHDMADPxceo8HbODn5uil5Gw9uVLFBjxkNLixNTKMFoi9eyWjwbS2q2f/fgRISalLRsYsyECTOpF9CSOGY0Ec9MuqdQn8nA4dIzewIAvtx0tEVcR5IsK2E4q4lHmsV9LnU27e9NaTAZgV4G8NaZ0eOZOVJSh0XvbscT727Hwje3YN+x6oDjhwozhRIAq9Oyo23r44+3c3Yoz4ynY3YSV6hu88YM6f7sdCaupgSF0pSQa5njWm5V10hRu+Tj5ZkB4l9rRpQkJcWahJlIVooeY6a0Ko7GjGeBSlc9bQ/olq2MpSU07LQ7BKXkncXEK2Gm+qCemeiMGeK9COWZqa534LVVv+Pfb2zGH0erAbgN6+c+2okTJxsgSTJO1ugJMwUXAJMwkymOPbz01JrxemaS15hpO3e7ILAsB4slFfX1VQAAo9EUkcUrSUxMMXqKfuhch0aW3X2l6uurYLGktog6NJW1drz99T6M6J2LMQOir0AbLwFwvb8xE+eMprIqG0RJhtHAIjvDrdkwe+rMOELUmSGUVsYxzOTnmQEAg0qH4RLEkKm6kdJgd+G/n+3B6H55GN0/PtWGyQJs5FkYeFbxHAQPM4U3JrSwKGEmUVOEvf3Pcry8co+SVTe6Xx4uGNsVr63+HQeO1+Lp93/FjRcOgCDK4FgG2enBs35CFc1zCPErmCec+APOrZ9gfB2L7RgSMgNMq2M2AMiSBKmmGNLJI2CMVvBdhsQ8rmhp88YMAKSnu59GiEETCSzLQpISX6qZQudaLxZLqnJNJzONdheefv9XHD/ZgMo6R4zGTHzDTCQrpjbOtWZIiCk/26oIKSMJM8WzcF6txgLFcwwYuAv8OwUJ2jVqo2P3oUrsPFCBihp7/IwZz9xYPN4Fci5Bw0zV7vmL2DNj8hoPdqcQUEvlx1+L4XCJ6JKfhqvO7oUeHTIAALf+ZRAeeWsrSqtseOaDXwEAOenmkN3YQ2pm4pCWLdWUwvHL+xAObwUAdAJwQ1oF9jUWBP1MnarGjGSvg3PHKoil+yFVHPVpyJxy1bNgrRlRjy0WqDEDd2n7jIwcpKVlQRT1q9U5jkFGhhU1NY3UY5Bg6Fzrg+P4FuGRcQkSnl/xG457aqfEmj2jrjMjxmDwkqfTwnYp2H+8Ju6eGaXyr6owXbiieaS+BwCcrLFDECVN8Wp5tQ2ZqSbd3hTimclQeWYYhoHBwMLpkoJWoI0WoskoqWyEKEkhF3S9KJlMHs8JKegWPswUmZlm4DnwHAtBlNBoDzRmSOfzaWO7KoYM4Dau5l46GA+/tVXxFoWrbxPamBF9tokE2dEAx/bP4Nr1NSCJAMOCP2UM7Pu34BRDKbJOvAvZ2QOMMXBuyNizDXbYPnsUUtUJ75u8CVxOZ3BdBoOxNF+7IWrMqGBZFiyrX63N8yzMZjNstugb21H0Qee69SDJMl5f/buiKwC0a2pEgm82U+xF8wpyrNh/vManQm48OHHSV/wLeD0zNg1jRpZl2FThJ0mWUV5t8/k8ABwqrsVDy7ZgVN9c/GO6virBdRphJsCd8ut0SXDFOT2b6C5ESUZ5tV3p6RMLDXZvJhOAkNlMNoegvB6pZ4Yco7bBqSkCJkLxTI06LblZVtx28WA88c42OAUpbIgrpABYiNwzI0siXL9/D+eWTyA73A1OuU4DYRp9ObisDthtGIyOv72Cdq4TaPz8CVin3gXGnOqzj/pGJzKYRgz48zVI9pNgUrJgGnkx2PbdwGbkg0mCB6jmHwGFQmlTrFh7EBv3lIJjGVw20Z0949KoqREJvmGm6AwjSZaVJ33iOYl3NpO6JxMhlGbG4RJBkopII0Wt9OzfDlYAAI6W1useS40iAPb1MhjC9AaKlnpVpli8qhmTvkykQq8iANYIM5V7CtalpxgVDUwkWIKkZ0uyrOnlUtO9MB1z/jIQfTpnYtyg4OEcIJwAmGhmwi/dsixDOPorGj/8Fxw//Q+yox5sViEs594B67l3gsty989j2nXD83WTYYMZ0snDaPz8MQjFeyFLqt9kYyVuSf8SJvtJMKk5sF5wDwy9xoLLKkwKQwagnhkKhdKErPv1BFZvPAIAuPrcPujZMQPLv9sf88KpbjQZbRjSpsqMIZ6PeHpmZFlGcWVwz4yWZoaEmFiGQafcVJRWNmrqZg6eqAUQmfGlJQAGwpfTjxZ1zZ4TFQ0YivYx79PmMT5T/DUzGp4ZEmLy92rphYSy/LN+6htdECUZDALnUs2AbjkY0C0n7HEUAbBm0TxPX6YwBfOk+grYf3wD4rHfAACMOQ3GERfB0OcMMKzvZ1PMPE6I2fgfpuF6y5eQKotg++xRwJQCvtMg8B3743LxE2Rx9RCtOUi/4B6wae3CnkdTQ40ZCoXSZHy5yV2MbdrYrhg7sABVdW6tQSwLpyTJPt6YaD0zJMRkMnLI8WSbxNMzU9vogsMpgoFvmEPRzGiEFYgXwGLikJ/t/oy/MSPLMg4cr1G2d7rEsGEId68d0gbAdwE2hKhAGwvqbBkihI6VAAGwRzPjFCQ4XKJPM0aS1p4frTFj1q41Q/QyqVZDRIX4gqFoZjRCrw5FAKx9HFmWIfz5M+w//Q9w2QCWg2HA2TANvQCMSfu8yXkddaTDevl8OLZ8DOHYTsDRAGH/Bgj7NyCLAcrENGRNuispDRmAGjMUCqUJIU/nI/u4e/+QkIYoyVGLQv2NgGgbTRL9RaqZV56w622uoILbSCHprSkW30XPHKLOjNeY4ZWu0P5hptIqm0/11toGJ9qF0WWQsXAso3g1CGShdMWoY/JHXZSNhNtixV8AbDZy4DkGgiijrtEJU4Z3Ho6Xu4/ZpSA6kWqwwnk1Sogp9iaLsuCA4fg2mBkn7JIx4DfhDJGaLdnr4Fj3hpKlxOb1hGXCdWAzQmeOpaqK5jFp7WGZeANkSYRYuh/Cke1wHdmBwxUCXq2bgEXtkrdnFzVmKBRKkyCrNCkkG0SdleF0SbCYIjca/ENU0XpmiKGVYjYgxWIAxzIQJbceIpI+PsFQqqj6aVTMnkXSJUgBixcR/5qNvCKY9a8CTLwyhJrG8MaMNy3bEFBXK1Q2TSzU23w9M7Isx1zFVt3KAHBnY6VaDKiud6Le5kI7lTFTVO7WE3UpiK4hYrCWBsQzk5kaW6l/2dGAxjVPA6X7MTs1Hy/UnR3wm1BSs/3CTMKx32D/4b+QbbUAw8E44kIYB08NCClpnpdn7kRJhtMlwWTkwLAc+ILe4At6o6bXNDz98kaYjJxPHaJkIzmUOxQKpdXjdHk7/pKFQZ1GHG2oyT/rQ4wxzJRiMYBlGMU7E69aM2Qx9y8JTzQzQGB6NtHMWE2cIgCuqnP4eKMOePQyhFod6eTB9DJA4sJMamPG7hSVEGMs+HtmAG3djCBKSmgr2u7OwTQzJH0/IwZjRmqsQeNnj0Eq3Q8A6GUoQW++OOA34S8AlmUZzp1rYFuzGLKtFmxWIawXLXCHlXQYMoC7AjXnKQKoVTivLsh1m2xQY4ZCoTQJ5CmaYxnlZswwjCp7JrrF0z/M5IpSANzgJyYlZf7jVWtG6Tzsp1HhOVZpGugfaiJeALOJR6rFoIytTBVqOujxzJDQlR6dT22DJ5NJw5hJhABYkrxeOXIO8dDNeD0z3oVWq9ZMSUUjREmGxcSFrfMSDEuQlgbk+tBKy9aDVHcSjSsfgVR5DIwlA3zX4QCA863b4XT6GhfqMJMsCnCsew2Oje8BsgxD7/GwXvQAuHZdIjo+w3hDjVrNJutUXrxkhhozFAqlSWj0PPVZTLxPeCHWxdNfKBkPzwzgfdKOlwi4PkiYCVClZ7u0jRniFVDSsz2hJodTxDFP+KRf1yzd4/V2zNbwzBiCC1CjpVGVKUaKyp2Ig25G2zNDas1454GEmDq2T406tGUNopmpbiBhpsiNGbH6BBpXPgK5ttSd8jztXphOnwWHzKMzXwHpyDaf7cl3kgIbbKuegGvvjwDDwDTmCpjGXwOGj847RIzBRg3PDLluUy3J2zEboMYMhUJpIvz1DQRDiOwNPfiHmaItmkf6MqV4buzEaxEvY6ZOWRQ0jBnPQhnKMwNAJQJ2GzOHimshy0BWmgld893CVj3p5KHCTF7jMn5hJmIomo0cOuW6C7LFwzNjI3VmzBphJlVYq8gj/iXHjoZgmhklzBQiLVsLsfoEbJ89BrmhEmxmAazT5oPNyANrScfP0iAAgHH3SsiS93gOl4g8thqD9r0MsWQfYLDAMmUujAMnx6Q/Ip6ZepuGZ8YW3AhPJqgxQ6FQmgStp2jAK2YM5pkRRAlPvrcdH687qPm+f3gq+tRsTxjE4h4fWZziVWuG9AvyT4UGvJkygcaM6HnfPUckPZuIgA+ccIeYehSmR2R8hfTMKJqZ+Hlm6lW9fQo8BQPjUTivQcszo9FsUvHMxGDMWIJ0l/YKgPV7ZqTaMtg+f8Ktc8npDMsF94BN9fZT28IORr1kAtdQDtfe9crr7e2HcXv6FzA5q8Ck58J64b/AdxoU9TkRiDcytGeGGjMUCoUS3DNjCK2ZOV7egD2Hq/DdtiLN9x3xCjM1kWdGS0hJjJVAAXCQMJNHM0OK5fXokKEYXzUN4YW1Xs9M4FiMCQgz1atCeKRoXazp2aIkKcafxRwYZlILjo97jJl4eGbUYSZZlr2p2ToFwFJ9BRo/fxxyY7W7Iu95/wfW4idK5i34yuY2UpxbP4EsOOH6Yx2mNHwCK+tCY3pXpFy4AFxWYdTno8ZKNTMUCoWij+CemdCpwERHYneKkOXAEFJAmCnqOjO+xozimamPPesGUGUzhdDM2F2+i4k6NRtQhZkqG32K5fUozFDqnOgRLCsCYA3PjNdTFr8wk5ZnprbR5WNwRIq6Aaf6mkpVspnc89BoF1BR6/4OO7aPb5jJ5hAUj6Ke1GypsRqNnz8Bub4CTEYeLOfdDdYcWPfGaGCx3tELLlMm5MZqNH7+GOzrXgMHCVsc3VA24saA/kmxQK75kNlMGtdKMkGNGQqF0iRoZZ4A3rBGsDATMVZESQ7Zr4ZUe401zJTqF2aKn2eGZDNpeWZIf6bQnhlSObiu0YWjpfWobXSBYxl0yU9Feqo3lVzL6FOjhJlCaGbiGWZSxNVmHmYjj2xPheUTMYSayPVkMnA+RQiJ54sYSsdPur0yWWkmJZwSDRZVajaZ32qP4Wg18SFrsMiyDPHkEdhWPeEW+6a1g/W8u8FaMzW3N/IsRHAo6zwZACCVuUOs6zEcbzWMg9EYX8MiJUgIDQjtUUwmaNE8CoXSJJB4vH+YyVu+XdsToA4j2ZyBpfrJ+1YzD4dLjLo3U4BnxqOBiEedGVmWVXVmAhcib7NJbc2M2ROGsph4ZKQaUVPvxM+7SgAAnfPSYOA5ZHienJ0ud/glWDNFSZZVoQMtzUz8jZl6Ul3ZsyAW5KSgstaB4ooG9OqUGdU+bXbtsGWqX+dsIv6NxSujPg4xqo0GDjUer51WiEmWZUhVRRAObILr4GbINe7vi0nJchsyqcH7NJFrvDxrEDrlboV08gjM46/Gd98wABwRdc3Wd27BPTOkaaeWEZ5MUGOGQqE0CcHCTIYwqdlqLY3dIQRkjZD3rSYeVXWOqDwzsiyrBMAezYxnobc5xIA+P5Fid4pKlpXWokCMFXuY1GwAyM+yoqbeiV/2uBfHHoVuvYXJyMFk5OBwiqhtcAY1ZuptLqUTt1bIiyyUriDGZTQ02HxFpAU5Vuw+VBlTRpNiHPudJzHQGmwuSJKsSsuOricTwWTkwACQ4fYKGQ0cqhsCa8zIsgTh0BY4t38GqeKYdwccD77TYJhOvRRseui2AIpBKQLWC+YBogDGaIHjix8BaLcziIXQdWZaRpiJGjMUCqVJCCYA9nYJDh1mArwaEjVEU0P2G01qtt0pQvKs8OTGbjFxMPAsXIKE2gYn2odpERAKojswGlhNoyhoNpOfZgYA8rIt2HusGrWeRYbUbQHcobEypw01DU5FLBwwFs8CnGrRboyYEM+MXw2fQo8IOJZaM/5NJgnk+5PhTrcvKvPWmIkGWZYBWQTL8rCYeDQ6BNgcAjJTTT7VfxUjZuunkKqOuz/M8uA7DQTfYxT4zkPAGPVdQ+oMP4YzABxpoEm6ZsdXIZISpM5Mo11QrkktfVUyQY0ZCoXSJIT3zGh7AtRZNWrRp//7ZL/ReGaI58DAs4pxxTAMMlKMOFljR02sxgwJ6wTRHYTTzKgXbH8jhXhmAI8xU2ULmU5O3guWnZKICsD1Gp4ZACg+GYtnRvt64jkWKWYeDXYBdY0uJczUIQrPjCxJsH/3IoQj22AcMBkZplw0OrzHrq53gIGEPtIBNH74jteIMVpgHDDZXf8lSLfqUHgzyrzXgyzL3t5McQ8zaXtm1Hoj/4eQZCO5R0ehUFoNQT0zYYrm+YeZAt4P8MxEYcz4ldonEGMm1lozSq2OIE+3SjaTypgRJUmZE4uqfxPJaCLjy8nwNsHUk05OPDrBirwlojdTg81Xj1TQzr3AV9Ta4XCKMBkjX5yDXU+A22hqsAs4VloHm0MAxzJKSngkODa+B+HgJgCA89fVmMNbscI4DDb7IMiShMzyHZiXsR75pTWQALcRM/AcGAecHZURQzBq1PpRG5fE2IkXKarO2Wpi9Wo1JdSYoVAoTYIi2DT5egTCFc3zFQBrGDMCEQC79xtNajap/utfGCxetWbCZYQodWbUITWVF0qtf1F7ZroXpvtUftVTa8brmdE2ZhLhmWnwm990qxGpFgPqbS6UVDaiS35genL4fWp7ZgD3uZVW2fD7kSoAQH621aepqR6cu7+Fa9dXAADj0AvgOvALUmvL8LfU9WjcdBQNW5wYW1sCcIDImWEZMiVmI4ag5ZlRGzb+XbNjRclmcgiQZBms55ryiqdjP6dEQ1OzKZQ2zrpfTyg3/UQSTOMQrtGkM8gCTyChGXJDjqZonr/ngKAYBzHWmglVYwbwtitwqIw1EmIy8KyPtiU30wJivqj1Mr7jDeWZCZ6WDSSmN1O9X9o74A01RaubCZbN5D6Oe57/OOq+riMNMQnHdsLx89sAAOPIv8A08i9IueRhbLGMg0PmYa07CrmmBI0w4fPGoSidcD9Mwy+MiyEDaOuWyHXOcyxYNvrWBVooOiMZsKt+Y+qeVskONWYolDZMcUUD3vjiD7y++veEHkeW5eBF8wyhBafq1+2anhlvNhPgFgCHq7PijxJmCuKZiTXMpNSYCdKsT0sArOhlNDRGJEzT2y+tWc94leq/QTUz8S2a5xIkxeOk9nzFWgm4kfRlMgWeBzEay6vtACJbjMXKIti+WQrIEvheY2Eccj4AgOEMOJB1Gh6uno4TOafCdOqleLT+EnxtH4j0zPQwe40Mre9AEf/GOcQEuEOLxCNHvGiyLMekN2pqaJiJQmnDlHnK4mulZMYThyswW4igaDSCpAKrX/fvWOx+36MrUe1XlGTwnP6nV3VRNzWk1kzMYaYwnhmLUgE4vDEDANdf0A+lVTYNz0z48YZqMgnEv2ge8UqxDONzLoUxioAbQ3lm/OZZrzEjNdbAtuZpwGUHV9Ab5tOv8QnjWUw8auQU7Go3GV37dkXtF2sBRNcxOxRaLSUSJf4lWM08nPVOZV6r6hywOQSwTHR6o6aGGjMUShumqs4dPom2aq5eyA2S55gA7UI4jYbamLFrZjMRz4x3ARNFGZHICpSCef6eGWt8PDNeAXCwMFNgbyYb6TukIY7tnJeGznmBOhNSvE2PADhomCnOmhnFULTwPoYB8S5FG2Zq1KjBQ/AvTKhH8yELTti+etbbauDsW8BwvvtW92eq9uiSjAYW5igEzKHQEgAT75YxzmnZhBSzAdX1TkU/RkJM+TmR642ag+QfIYVCSRiVxJgRpIhDM5GgDjGpFzQgfF0T9euh6syovSqCFNlCrBTMC/DMxEkATDpmBwkzmSMIM4VC3ek72PfpDTMF8cx4nvxFSYYY4TxqUR9Ej0Q0M2VVtqiM6VDZTGoPmNnI+WR8aSHLEuw/vOJuG2BKgXXKXM3eR+S7sNkFRZeUmWIKuKZjRVsA7DFmEuSZ8W9p0JLEvwA1ZiiUNk1VnVtTIMO9eCUKr/g38oqzYT0zHmPHbOIUYWykhfP8i7oR1P2ZYjH2vFVUQ4eZHD7nGrkxQzKUREnWDB3KqlYG4TwzQHxEwP6ZTITsdDOMBhaiJKO82hbxfkOFmdTz3KF9Slhjw7n1E3cKNsvBcvYcsBn5mttZVVk/1SFaGcSKlmfGG2ZKzLLt39KAeGY6tADxL0CNGQqlTUPCTEB8U3H9CSb+BcJ7ZnxSs0PUmTEZOHCerJ9IM5qUBdesLQB2CVJAdd5ICGvMeBZJlyAp3hDFADTpfxI38KzyhK3lTbI7RWWeg3lm1MZMPK4J/4J5BJZhUJDtfuo/Xh55qClUmEkttO4UZjF2/fkznNtWAgDMp18NvrBv0G3VYSZv9d/46mUAb0aZjwBYCTMl1jNDwoJFZe7vJNz8JQvUmKFQ2jBqYyaRuhkl80TjKTqsZkZQ60i0wkyeJ1aeU0S/kZ5LsKJ5JgOn6CGiDTUJoqQYYf4LOkHdroDoZuyKZiYyaaOS0aSRTk68MiYDF7RQHcswSip4PArn1as0M/6Q+jKHimsj2qcoSco8+XdhB/w9M8EXY6FkH+xrXwMAGAdPhaH36SGPS4xOm0ozk5kQz4yGANjz+4ilR1goiFey0S5AECUly4yGmSgUSlIjyzIqa9XGTNNoZvwxhqk4GyrMJEmyYriYjJyyCLsiPJeGIGEmIPZaM2QxZxjt/QNubwjnqR1CjJjGKMJMPuPV6PZd2xDaQ0SIZ+G8BltwQ65HB3dK84HjNRHt07egYODirj5WsMVYstfB/vULgCSA7zocxlEXhz2u4plRa2YS4JnR+k0oAuCEhZm8LQ1KKhshSrIuvVGyQI0ZCqWNYnMIPhoNV0I9M8H1DWEFwCEqAKvHb+RZcB7PTCRhJlmWvdlMGk/5GTFWAVYymSwGpbKqFsQDRM4pGgEwoPbMBI6XnEOwVgaEeBbOCyYABoAehe7U8sMldRF508j3ZTJy4NjAZcxs5JCTbobFxGlmfcmyDMe6NyDbasBmFcJ85vVgmPDLoW+YyaOZCTOX0aCdmp3oMJNXM+PVy4TXGyULNDWbQmmjVNb5ehqEZtLMkBu3S0dvJv8KwMQAYuA2igwez0wkXianS1K21wqFaBWicwki6hpdyE4P/9TqLZgX2htiMnJoUHUpJl6oSDQzQOhaM0rDyzAdkOPqmQkiAAbcab9WTyfqovJ6dM3XV3yuMUhYkMAwDP41awRcgqRpDDr3rodweCvAcjCfeQMYgz7vCgkzOZyi8vtJrGem6QTA6mym40omU8vQywDUM0OhtFmq/I2ZFuCZEUTJZ4FVnlYNHBiGUQTA0TzlcyyjqUdQGweSLGPDrhLMe2kj/u8/P2P7n+Vh9+8tmBfagPBvNhl1mClEOnm4gnmEcKG/SAgmAAbc+pzuhSTUpF83E0r8S0j3a8JJcFWXofHHtwAAxhEXgWvXRfdx1ccjBScTkc1EPGOCKCnFJhOdmq3OZmpJDSYJCTVmFixYgHnz5gW8vmHDBsyYMQODBw/GlClTsGrVKp/3HQ4HHnzwQYwZMwZDhw7FnXfeicrKykQOlUJpc/gbMwkNMylptBqp2Z6FU33jJgiiFJAyrg41+esI+CjCTOq0bC2XerpnsfrzWDUefnML/vv5HlTVOSDLwDtf/xm0cjEhXJNJghJmUjwzsWlmtAr9hevLJMsSXHt/RG/2CID4VAEOlvZOIMbMwRP6dTO2EJ6+UMiShPKVS9wVfvNOgXHQ1Ig+z3Os4rUi12ViPDOqjDKPMa94ZhJWNI9kMwktrsYMkCBjRpIkLF68GMuXLw9478CBA7jhhhtw+umnY8WKFbjkkktw9913Y8OGDco2DzzwANavX4/nnnsOy5Ytw8GDB3HrrbcmYqgUSpulstbu83diw0ykj05wzwwQGNZQe2UUgawqPdupymQCAN6jn4ikc3awTCYCMQ72FdXgUHEdzEYOM8Z3R3a6CRW1dnzxy9GQ+w/XZJJAjBm7yz2eaD0zoTp9h+rLJEsC7D+8CvvaVzFNWI1ctiZOAuDgnhkA6OlpyRCVZ0bDOA6F49cvYD/2O2Awu3UyGnqbcKi/D55jgl43saDWxRCPjLoEQSIgxmZNgxMVnntDS6kxAyRAM3PgwAHMnz8fR44cQWFhYcD7y5YtQ+/evTF37lwAQI8ePbBnzx688sorGDNmDEpLS/HJJ5/gxRdfxIgRIwAAixcvxpQpU7B9+3YMHTo03kOmUNokAZqZRGYzhQgzqTUALkHyuVmTGznDuFsB1NQ7fXQzziCemYjCTGE8B7mZFvcYAJw+uBAXje+OjBQjcrMsePHT3Vi98QjGDsxHuwyL5ucVzUwYY8bk75kJ0c4gFKEEy8FaGciCE7ZvlkI8ugOA+1zPseyE0zU6omP74xZXhzYWu3k8M2XVNtQ2OoPWv1FDPH2RGHrC8T2w/fIhAMA67iqw6e11f1aN1cz7CKkTIZBlWQY8x0AQZcVgdwiJ780EeH87manGsDqvZCLunpmNGzeiR48e+Pzzz9GxY8eA97ds2YIxY8b4vDZ69Ghs3boVsixj69atymuEbt26IS8vD5s3b473cCmUNku8w0yyLAeEiQihBMAc601L9g/ZqDUxVqXkv8ozI/g+rXqL5kXimdEumEfo1TkTN104AA/OHoWrz+2jGAsj++SiT+dMuAQJ73+3P+j+Fc9MkFYGBLPBKy6VZTnqbCYyvrpGJyQ/D5VWKwPZ2Qjb6ifdhgxngHGkO0V5mPEw2LrSiI7tj90pKuGYYAtjitmgtDY4qNM7E6pukT+yLMOxYzVsqxcBkghr71Nh7BO6nkwo1NdwIgrmEfx1S84E92by/212zG05XhkgAZ6ZK6+8MuT7JSUlyM/3LRWdm5sLm82GqqoqlJaWIisrCyaTKWCbkpKSmMbGx/kiIDdO8n9K4qBzHX+qPcYMA3c7A1mWwfNs1HO9ePkOlFQ0YuHfTw14eiQLc1qKUfN3aOBZiE4REnx/p8QmMRk4ZVF3CpKyDfEmmYwceJ5VQlb++wkFaeiYajUE/czoAdrl7WdO6YP7/rsRW/aWY++xavTvlh2wDTFmMlK1z53Ms3J+ouTTXiLYnAUjK90MhgFk2a0vUi+4xEuUlWEGz7OQGmtQ//kiiCePAkYLUqfOhaGwDw7u3IGOjv3IP/E9eH6Y7mP7Y6/zLsDWEE/5PTtmoLiiEYdKajGib274/ZLvzBL8OwMA2dGIhu/+C9ch90Oyqc845E67CfU2CQwTnfGuDm1lpZnivq4QjAYWjQ5Akt3XMgn5Wcx8Qo7J8+6GmWRuO+elxXScpr5nR2TMFBUV4ayzzgr6/oYNG5CdHfhjVmO322E0+j6hkL+dTidsNlvA+wBgMpngcERXtApwu+2yshIjZkpP13YvU+IPnev4UeWpk5GTYcbJGjuMZqPPbyTSud51sAKCKKPOIaFnrjfFVpK8XobCvHRkaaQzm4087E4RZovvGMo8Rf3MJh7pnqwilueUbXhPBlCK1f050vvJZDLo/r0Tgykn0xrxPSIrKwXnndYNn/90CO9++yeevWOCUriP0OgJixXkpYfcf3qax+hgWBjN7nsgwwD5uelg2chCGRkpJlTXOyBz3rlyCZIS8ulcmIlUo4wTK56BePIouJQM5F/+L5jyuwEADrY/Ax2L9iOncidSpGoYczpEdHzCyXqv4DjUuQ86JRc//lqMI6X1ur4DIuVpl639ncmSCMeJP1H+2fNwVRYDHI92k2cjbejZYBgG6TFETzJV129uTkrC1hWziQfqnTB5fpfEyZYdxXWql7QUI+xOd5ZW7645cTlOU92zIzJm8vLysHr16qDvZ2RkhN2HyWSC0+kbyyV/WywWmM3mgPcBd4aTxRL9pEiSjNraxqg/rwXHsUhPt6C21hZxLxhKZNC5ji82h6CEftp5jJmaGhuqqhqimmtB9NZqOVRUhZxU72phcwjKjdjpcKKqKjD7h2hdKiobkKmq9XKy0p1VYWAZEE3kyapGVFW5X6+qcd94WcioqmqA7OlrVFNrU7YJx8kq932BZ2Tdn1EzdXRn/LCtCEdL6vDRN3sxeVRnn/erPc08GVHU3D+Zbxaysn1xmTvcYjZyqKmJ/L6VZjWgut6BoydqlPkkgm+OZeC0O3D88xfhKjkAxpyKlOnz0WjKRaNnfNWGPPzm7IiBxiKUffceUib9I+IxAMCJ0joA7nBQqLktzHbf2/cdrUJFRX1Y462KiNclyf29yzLEkn1wHf8DQvE+CKX7Ac+izKbmIOWcWyDmdUddnT3m+wivGprFwEZ1zeg6jmcOKqoaUJVpUkT0TocrYcdU67OyUwwxHSde9+z0dIsu705ExozBYECPHj2iHhQAFBQUoKyszOe1srIyWK1WpKWlIT8/H9XV1XA6nT4emrKyMuTl5cV07ERla4iilNBMEIoXOtfxgdTIsJp4xW3ucIk+cxvJXDeqOjSXV9l8Pkcq0fIcCxaM5j5JeMhmF3zeJym4Bp5VdDENNpeyjfI+x0EQJKXCrtPvXEJBKvRaTHxU15bZwGHGGd3x5pq9+PznwzhzaAdFFOruUu3N5Aq1f6KRsNmFmMdEBL5VtXbl80dK6pT37FtWwrV/I8BwME+aAzk11+c4PMdgjW0wBhqL4PxzAwxDpoHN1A61hYL0hwp37nmZFiXEcaSkDp3C6DWIaNtscO/XsfUTOLd+4ruRwQy+82CYxl4FmNOivrb9MasW/HSrMWH3I//fBBGG8yybsGMS3QzLMMjNtMTlOE11z25yAcKIESOwadMmn9c2btyIYcOGgWVZDB8+HJIkKUJgADh06BBKS0sxcuTIph4uhdIqqfJ4C7LTTd4MoBhuOOriahV+Kd+hMpkIwQrnkb+NBk5puGjzSc0mAmCSzRR5BeBQrQz0clr/fHAsg+p6JypqvOdvc4QXwBLU7QyiTcsmaNWa+XZrEQDg3A6VcG5ZAQAwjZsJvrBPwOcNPIciMQfFlp6ALMOxfWVU4yBhrXDnzrIMuhV4iufpqDejvqbEqhNwbv8MAMB3HQ7TaVfBOuNBpM5aCstZN4I1B7YziAX1d5KIVgYEfwGwQ/DN3EsE5DeQl23xKZnQEmjy0c6cORM7d+7Ek08+iQMHDuC1117DmjVrcN111wFwh7LOO+883Hffffjll1+wc+dO3HHHHRg1ahSGDBnS1MOlUFolVR4tSlaaWdUCIAZjRpWF5F+/plExFoIvzOTG7RKCZTOxbg0BfJtNOvyqoipF86RIiuZ5Uoc1WhnoxWjgFG/CgRPejJx6m7dLdbiUWm9qtuAtmBdBx2ypsRqywx0W8K81U1zRgJ0HKlDIVWFUxecAAEP/s2DsO0H7fDwL2a60sQAAYf8GSDWRJ2CEqv4LALIoQKotg+y0oUeh2+jQ03RSqVtk5OD46S1AEsF1HgLL5FtgHDAJXLsuUdWQ0YPaKE9EwTwCqQJMhL/edgaJSc0GvL+BllT5l9DkvZlOOeUULF26FIsWLcKyZcvQsWNHLFq0yCdd+6GHHsIjjzyCOXPmAADGjx+P++67r6mHSqG0WkhadlaaCaRMRiyp2Q5VcbuKWl+hfqi0bEJQzwzxvPCcT5M/7/u+/WqayzMDAD06ZOBwSR0OnKjBqf3cIfG6xtCLuRqlaJ4zcs+Ma99PsK99BZBlMJZ0nMZmIcNqRFrJn7Cv34iaw8dxS1oVOhmrwYgOcIV9YRrz16D7I8ZMOZsLrvNgiEd/he2HV2A9724wvH5vRLDqv1J1MZx/rIWw7yfIdnf46yzWgCEZZtiPp8C5+2wY+k0MWsOFzE9q+Q6IJ34HOAPMp4XOpI0XPp6ZBLQyICieGVfTpGYDQJe8NADFmll5yU5CjZm33npL8/Xx48dj/PjxQT9ntVqxcOFCLFy4MFFDo1DaNJUkzJRmUnoHJcwzQxbmkJ4Z7caGDpWxYjaRxV4rzETqzERRNM+uveBGSo/CdHy71beSbZ3O6r+AqjeTS4yoyaRr/0bFkAEA2VaLDNTiNDOAhj/h2gN0AAADABlgMvJhmXQzGDaEcWnwLqTm8X9FQ8mfkEr3w77uNXdjRp2F4tTVf2VZhnBwE1x7voNYvNe7EcsBkghWcqE95wJQB8dPb0GqK4fp1MsCjiWIEpwuCWbGCeOvnwIAjEMviLoIXqQQo5phoKvAX7QonbMFyaetRyI9MxOGdsCQU9ojM4FGWqKgXbMplDZIpcozQ+pKCEL0FYDVxkxNgxMuQVK8LXo8M0aD71Oosl9VGElLM6P0ZiLtDCIsmucSRMW7E6xonl56eMryHy2tg0sQYeA53dV/Ad/eTHoL5rkObob9+5cBWYahzxkwjb4cUk0pju3/E5s3/YY8i4Cc3HbYdMgGY2omLp06FHxez7DeFbVxyWbmw3L2HNhWPwVh/0Y4MwpgGj497PkAKs+M2QDn1k/g3OY2PsAw4DoNgrHPBHCdBwGiANlWg6Xvrkd72xFMtf4K1841gLMRpnFX+4SMyPU01bIDsNWAyciHcfC5usYTD4jRm55ijDhlPhLId+B0iT5GvimBmhmGYZCVlrjQWSKhxgyF0gYhYabsdDPKPenNsfThcfh9tqrOjtwsd1VXPX10gnlm1L2XiJeCFLnzeT/KdgZEL8MyjC4vSCjaZZiRbjWgttGFIyX16NkxQ3f1X8CrmbE7RaWZZijNjHB4O+zfvgjIEvheY2E6fRYYhgXXvisMaIcv1nKwSDzMxzlUORy49qy+MHQo0HUu/mE/vkM/mMbNhOPHN+Dc+jHYjDwYeoZvdUC8XgVV2+Dc6zZkDIPOhXHA2WBTVaEMlgNjyIWpsA++3J2Jrj26oF/JZ3D9sQ6y0+7uo8S556K63oEOXCVON7m9O+axM8FwTVd2v1tBGsb0z0fvzpkJPY5XACwpRj4DBNQxorihxgyF0gbxCoBNys0xFs2Mv0elotbhNWb0aGYM3hu31n6NBtYbhlFrZvwFwBE2miSLrdXMx9xjh2EYdC/MwI79J3HgRA16dszwdszW45kxeLOZvJ4ZbQNLOLwdtm9eAGQRfM/RMI+fDYbxLnKk6q/NIcDmEJCeYlR0PHrQEmQb+06AVFMC1841sK99BWxaO3B5PUPup97mQj9DEdrv+8G9j2HTYBoxI+j2PTqkY8PuEqxv7I5hZ90E+3cvQji4CTZHPbjcHpAdDeArqnBt6p9gGRl891HgO/bXfV7xgGNZ/P2Cfgk/jloArO7LlIheUK0BasxQKG0Mu1NQvCVZaaa4ZDM5/IwZtW5GTx8dxaXun82kDjN5jCEtz0y0mplwTSYjpUeHdI8x49bN1EdgzBDPjEuQ0ODxGJn9DEDZXg/7xvcg7FsPAOC7jYB5wt8DMnesZh4cyyg6i4lDO0SUaksWUnXXcgAwjboUck0phCPb0bjyYTBp7cFmFoDNyAebWQAuryfYLG+dnQxHCa5OXQfG4z0yDr8o5HFJevaxsnoYuo8DYzDD9tVzEI/vgXh8DwAgDUAaBzgZI1JCiJhbOmoBsH9DVUog1JihUNoYJMRkMbkNBD4uqdm+n1XXmokkm8nl0g4zmXhWqU5q19LMBGQz6TRmSB0UHQ0L9dCj0K2bIenFimZGh7Gk1sdUqYrNAe7ie8KBjXD8/I4n+4eBof9EmMb8FQwb6L1hGQbpKUZU1TnAcywmDI2sHUEw45JhWZgn3gDbmqchFu+FXFsGsbYMIn71bmNOA1fYB0xuT1xt+gomRgAK+sI8/pqwXoX2ng7ltUR31WkgrNPugeuPde5QlMmK34ps2HqwHnm9BuLClKyIzqsloRYAq8OtFG2oMUOhtDG84l93jxlDEL1KJPgver6F48IXzTMGSc12qLpmm1WNJgVRAs+xqnRVXwGw3tRsUocllJ4nEroWpIFh3AZjZa3dq5nRkfXCc6ziTan2GDNmIw/ZXg/b9y9DPLYTAMBmdYB5/DVhQzzEmBndP0+pO6MXtV7DH8ZghuX8eZBttZCqi73/VRVBLNkP2V4H4eBm4OBmpLFAkZCFU86eEzJ7ipBi5mE0sHC6JFTW2ZGXZQXXvhu49t2UbX4t2YNfnCX4S05hROfU0qCemcigxgyF0sYgeplsT9ZCNLVZ/FELcZ0uySfMRLwfoSsABymaJ6hSs1Vl5O1OEakWVnnfP8yktxfMht3uQnBd8+NTJdZs5NGpfSqOltXj4InaiOrMuD/PocEuoMbTAsJqZGFf97rbkGF5GIdNg3HwVEUMG4rxgwqwVpJx/mldIz6PYJ4yAsMwYKwZYK0ZgKqCsCwKEMsPQjzxOxqP7MahEzX4wHUmHjXra1jIMAxy0s0ormhEZY3bmPGHGOPZaYENS1sTagPfXxtGCYQaMxRKG4O0MiApmDwfeW0Wf4gHJT/biqOl9T6F87xhphDZTAZtz4za88JzLIy824CxOQSkWgwBT6yGCAyzQ8W12F9UA45lcOaw6LpCa9G9QwaOltXjwImaiOrMAG7dTINdULQuGSe3Qzi8FWA4WKfdCy63u+5xnDmsI84c1jHyE0Dw7yMcDMeDz+8FPr8Xjuaegef/tw25mZE1CM72GDP+xRcJ6rICrRm1ANhfG0YJhPqsKJQ2RpXfYmCIYzZTQY77Cbyy1g7ZU8Qtkt5MQVOzPTdxRQTs2acjhqJ5X20+BgAY1TcvrmXpexS6Raz7jlUr49QTZgJ8F6sMpgGpuz4CABiHT4/IkIkVEuIQRAmSHJ3HLlj133DkpLu/C//ii4BbO6QY4+mt25hRh5n8tWGUQOjMUChtjEpVjRlAFWaKRTPjMTrys91hAacgod7mgiTLimA3ZNE8v9Ltyn4F30aSSn8mpwhRkhQPjH9qdrgwU2WtHVv+KAMATB7ZSc8p6oYUzztU7C7TzzJMSENOjVmpKyPjr6k/g3HZwLbvDuOQ8+I6xnCoM5+i1VKF68sUDHJd+jcsBdyGMbnWslu5Z8ZHAEzCqVQAHBRqzFAobYzKWl/PDM/HIZvJY3RYzbzSSbiy1gG7QwB5rg9VzTZ40TxfrQDJaLKpFjX15xXDLEydme+2HYcoyejVKRNd4qSXIeRlWXyaaqZaeLBBsnhkwQnH3p/gLHd7iYguaKxpH/oait09h868TjNjKZGoPQB6jJmisnrMe3ED1vxyVHmtIcoGnjkeY0bLM0P0XqkWg6Kzaq1QAXBkUM0MhdLGqFL1ZQLUYaboBcAOpzfck51uRk2DExW1dmVRN/JsyDonhiAaDaU3k+ez3lozgrItA68nQU8FYIdTxNodxwHE3ysDuEWsPTpkYOeBCgBAaogQk2PDO3D9/gMavwXYrEKMdnUCY0jBdOtWAIBp1CXgMps+a4djvZlVTpcIhPGubN9/EmXVNrz//X6kmHmcPrhQKUgYaZsIr2cmUDNT6XfttmZ8U7OpADgc1MyjUNoQDpeoZBeR1Oy4hJkEr9FBNA8VtXZdTSbdnwtSAdgvi0PpLO0QfdK2Sf0STkdvpp93FaPBLqB9phlDerbTeYaR0d2jmwGAtCCGgFRbDtcfP7r/YHlIVScwxP4Lbkj7DiZGwAGxAIYBkxIyPj1EkrJPdFgAsGzNXuw6WBF1mEmtmZH99DptRfwLqDP8JNXvixozwaDGDIXShqj2LAYmo7fXUaT9jLRQd6/OVoUJ9BTMA9QLp1czI8tycAGwU9B0vYc7F0mW8fWWIgDApBGdEtYokOhmgOBNJp3bV7rbEXQcgK5zX4N10j9wwnIKXDKLesmE1cyZPi0KmppgtX+0qPKEhDJSjZBkGS98skspHBipAJgY2UR35XscjzGT3rrTsgHfRpNUABweGmaiUNoQ3hodJsWbYYiDZsahMjpyVGECPZlMgPrG7R2D2iOghJmUztmiZlXUcDVzdh2sQEllIywmDuMG6mu6GA3d8tPBAJChnckk1ZTCte8nAIBl1Ayw5hSYep2GHYdz8N2mQ2AgIz8vM2Hj04PbM+AKKIioBfHMzJzcG99uLcLvR6pQVN4AIHLPjIFnkZFiRE2DE5W1Dp/5q6rzrZHUmjGq+pXRMFN4qJlHobQhiKhS7aaPZ6NJo4HV9MykhNFNeBtNqvouqYwZkrJsNnlbGijeIFUxPY4N7Zn52pOOPX5wYUhBcqxYzTwK27nT1LUWc8e2lYAsges0CHy+t5KvycDBBR5OGMJ6sxIN8QIEK5ynhhjJuZkW3HzRQHRs7y2SF6kxAwA5GdoZTf41klozRpXGjIipTRH012pr0JmhUNoQVRrVU72amRgEwIK3uF1OhkozQ7pSh1mYjaqKs0QnQYwVnmOVcJA6zKS43nl1mCm0l2nvsWoAwOmDEi+qHdA9GwBQ2M63iq1YfQLC/p8BAKYRvo0XvanZobO/mgKDzjCT0yUq4aCsdBOsZh63XzIYWWkmsAyjpOtHgiICrvE1ZirbkGdGLZgnxRepZyY4NMxEobQh/AvmAd6bpiTLkMKkNAdDqVBq5JSQUk29EzWeRovhBcDuMchwh4gMPKMqiOe9qXtTs0VVqwNVmImEzDTOQxC9dWki7VUUDTPG98DofvnonJfq87pz60pAlsF3GerTcwjw9TKpDZvmwBikxYQ/pCmm0cAqRmt2uhkPzT4VNQ0OxcsSCWoROUGWZW9ZgTagmVH36mpQjBnqfwgGnRkKpQ2hZcwQ0SwQfajJqfKSpFkMioF03KObCC8A9i7iZPH0F/8CvhWANQXAbPDeTGo9jqkJFgUDz6JLfppPp2ix8jiEA78AAIzDLwz4jFl1rs0dZtLrmVFEuWlmn3O1mnmlInSkZGvUmrGpMtiy4lixOZkh34HimaHZTEGhxgyF0oYg3ZgzNTQzQHQiYEGUlF5CJE2aLEZF5fUAwguAeY4BWQbJ4qkVRvJWABZ8Mqj8z0UQ5YC0XqLHYRjfc25KnNs+ASCD7zocXLsuAe/7eGZMzbtwBStk6E8iRLk5GrVmiF4mxcz7zFNrhhjyDTTMFBZqzFAobYiaBnfYJ0MVZuFYryERTel6LY+Ht1aIezEK52VgGCagcJ5Wp2B1mMmhmc2k8oL4hZq06tI0JcKJ3yEc3AyAgdFPK0NQdwZvds8MEWW7QoeZElHITqsKsNer2PpDTARiUJJruSk8ii0VOjMUShtBlmXUahgzDMN4tSbRGDMaHo9sP02DVUcVWEWj4fIPM6k0Mxp1ZtQ3eE7lcfEvnNecnYdllx32ta8CAAx9zwCXrd3N2tcz09yaGX2eGaWQXRwbP2Z79lXT4FSO7+0p1jZCTECgJ4Z6ZoJDjRkKpY3QYBeUJzz/2iexpGc7NTwe7fyNGR0Ls79Gw6vDCVzg7Q7Rm0Fl0PbMCJJ/a4TAsFVT4fjlfch1J8Gk5sB06mVBtzP76IOSI8wUiWYmXqRaDMrxSXhJq6xAa8e/BUhzXLstBTozFEobgYSYUsx8wE3SoFTOjTybiYR71DUwAj0z4Y0Zf0+A0ilYI8zkcImwOwONGZbxhsz8z0WrLk1TIBzfA9ee7wAA5jNmgzFagm6rHpulmbOZDEqLiTDZTAloMaDWXRHdTCKOk+z4Gy/UMxMcasxQKG2EWo/4VystOZbO2VrVSXP8QgH6PDO+i6dWCXd1unJtvds4U4eZGIZR9WcK5plpugVBdtq84aV+E8F36Bdy+2SqM6O3aJ5/49J4oe7R5D5OGzRmaJhJN9SYoVDaCKTmS4aWMcPp00dooZVVlJ0RhWfGb/HUCjMZeFYZK/E0+RsnJNTkHzLzamaa7rbn+GU55PoKMGntYTr10rDbJ5UAWEeYySVIqG30FMyLs5Hh9cz4GjP+Xr/WTIBnhoaZgkKL5lEobQTiycjQqNERS38mhxAo1PV/StfjZfDXaGgJgN374lDXKKGmwaH5vtvYEQPCTI4m6m8jyxKkiqMQDm+H6/cfAADmM64FYwi/CPMcC5ORg8MpRtygMd7oKZpHUv0NPBtV24JQ+Gc0JSJrKtkJ9MxQYyYY1JihUNoIxJORrtH4MFwbgFBoe1A4pKcYUdvghMnA6arr4h9m0krNBtxakrpGF2qUMJPv+xynXThPy4MUL2RZhnBwM4RDWyCe+B2yvU55z9D/LPCFfXXv69qpfVHb4Gz2cIoez4xalBvvdHelP1ONHTaHAJvD/f1ltpGCeYCvAJjnGHAsNWaCQY0ZStwoKqvHm1/txUWnd0ffLlnNPRyKH0qNmdRAY8aghJmiEQBrGx056SbUNjh1hZgADQGwUkfG3zPj3p9WOwPAey7BPTPxXRBkwQH7utch7N+oGoQZXEEf8J0Hw9BnfET7G9knN67jixY9qdmJ7GKtFgCT41hMfLNriZoS9bVPq/+Gpu1cFZSEs/3PcuwvqsGG3SXUmElCtGrMEHgudLfpUATTomSnm3GouE639kMpmuenmfH3pPinLPsbJ1wQL1Mi6sxIdSdh++o5SBVHAIaDcdA54LoMAZfbHQzbsm+v3u8jeJgpkaJctQC4LYaYAF9DnYaYQtOyf22UpMIl+nY7piQXWtV/CTFlMwUJBxHNQ7gmkwSvJ8CTzRTE8+LfgNHfOOGDhJnirZkRTvwO+zdLIdvrwJjTYJ50M/jCPnHZdzLg1cyECDMlsCov2adTkHCsrN7zWhszZtSeGZrJFBJqzFDihugpUuZwUmMmGVE0MxrGjCGGonkOjXovgNeYSdHrmVE0M/7ZTIECYDUB2Uysdudsrbo10eL8Yy0cPy4DZAlsuy6wTL4VbGpOzPtNJvQUzatKYFVeA88iI8WImgYn9hfVJOw4yYyPZ4aGmUJCjRlK3CDl48NVDKU0PZIko05HanZ07Qy0tS0j+uRiz+FKnDVcu3S/P4GaGW0jyb/Mf2A2k3bIzGt0xeaudx34BY51bwCQwfccA/P4a8DwgXPa0olUAJwIstPNbmPmeI3nOG0nLRvwFQDTvkyhocYMJW4QY8ZBw0xJR12jE7Ls7p/k38oA8O02HSnBtC1ZaSbcdslg3fsJaGegkfINBFbGDcxmIkXztLtmx+KZEY79Bvv3LwOQYeg3EaaxM5ulaWVTQIzIUKnZXgFwYoyMnHQTDhUDdQmqZZPs0DCTfqipR4kbJMxENTPJBwkxpVmNYNnAxdfAaxea00OwejCRoiyeSqPJIKnZAQJgbc1MgGcmxgrAYul+2L5+DpBE8D1OhWnsVa3WkAFUxmWQCsCCKCmi8kR6Znz+bmvGjE+YiS7XoaCzQ4kbRKNAPTPJR22IGjNAbGGmeAlrAxtNkp5P4QTAWkXztHozefYXRW8msbIIjWueBgQnuI4DYJ7wdzBM6759hkvNrq53QIbbeEy1JqbAX46fMUM9M5RgtO5fI6VJUTQzYXq5UJqeUDVmgPgUzYtVWOu/eHq7YgcXADNAQEE+jg3nmYnstifVnYRt9ZOAowFsbg9Yzr4FDNf6I/TqIoayHBh+JCGmzFQT2AR5qPw9M21NM0NTs/VDZ4cSN5RsJuqZSTpCpWUDXq9IVGGmINqWSDH6VwBWwleBFYCVzxi4gFBPMMMsGqNLdjTA9sViyI3VYLM6wDplLhhD2/AOkO9TlgFRCjRmKmsT3yspJ8M712Yjp7sAY2uBemb0Q40ZStxQe2a0nuQozUdtiLRsIE4C4BhTRwPDTMFSs70LmlaGR/AwU2ThMFl0uQviVZ8Ak5IFy7l3gjGn6vpsa0A971re1kRW/yWow0xtLcQEeL1jQOy/r9YONWYocYM8vUmyHNWiSEkc4TwzSqfpEJkrwYiXZkbdNVsQJeV6ChQA+3pm/FGK5kn+YSb9XbNlWYJ97asQi/8ADGZYpswFm5odwdm0fHiOBfF5aV0XpCpvIo2MVItBMaramvgX8PV20jBTaBI6OwsWLMC8efMCXv/oo49wwQUXYMiQIZg8eTJefvlliKL3x1JVVYU777wTI0eOxKhRo/Dggw/CZrMlcqiUOCCoFg9nFIsiJXHUeLobBw0zxeSZiU8xOrVGQy069Tc+zCa1jkDLmIndM+PcvMLda4nhYDl7DriczjrPovXAMEzIWjOJbGWgHgMJY7U1vQxAw0yRkBBjRpIkLF68GMuXLw94b+XKlbj//vtx1VVXYeXKlbj99tvx0ksv4T//+Y+yza233oojR47gjTfewLPPPou1a9figQceSMRQKXFEXdeDVgFOLsJ6Zkg7g2iymYIIdSNFLQAmhoeWwNdHM6Mh5uU0UrMlWdZdAdj5x1o4d3wOADCPvxp8xwERnknrwZueHfh7rkpgKwM1pEdTWwwz0dRs/cR9dg4cOIArrrgCH3zwAQoLCwPef/fdd3HhhRfisssuQ+fOnTF16lRce+21+PDDDwEA27dvx6ZNm/D444+jf//+GDNmDP7973/j008/RWlpabyHS4kj6l44tApwcqFXMxNbnZn4aWbUfZn8Bb7qbCYtw4TXKJrnUmk+QhldsuCAY6P7Icw4bDoMvU+P9DRaFeQ7DeWZSXSLgT5dssAwQK/OmQk9TjJCPTP6ibsxs3HjRvTo0QOff/45OnYMLGN+1113Yfbs2b6DYFnU1LjLVW/ZsgXt27dHjx49lPdHjRoFhmGwdevWeA+XEkfUGQ/UM5M8uAQJDXYBAJCRqr3wGOKQmh3rk6O64qw3JKQt8CXp16E0M+pzcajCnqEWBeHAJsDZCCatPYzDp0dxFq0LQ5BaM6Ikobo+8QJgADhvTFc8f/t49O/atjRLgK8AmGpmQhP3PLcrr7wy5PvDhw/3+buurg7vvvsuTj/d/QRUWlqKgoICn22MRiMyMzNRXFwc09j4OLvpSNl0jqMXGQCIqgwmUZbjOt90rqOHhJg4lkF6qlGzJggpJCeKckRzrRbqplgMMX3nRNjrdHn3aTJwmvu0mHjU21wwGwPfJynekuoaJPsz8GxIY6bxjx8AAOb+E2AwNE0acDJf28TzJUq+v+eaGnd7DI5lkJVhTlidGUJanHpfJfNca8FxDBjGnR5vMfFxX8MSSVPPdUS/1qKiIpx11llB39+wYQOys/Vbzw0NDbjpppvgcDhw9913AwBsNhuMxsAL12QyweFwRDJcH1iWQVZWStSfD0V6uiUh+215eG9oRpMhIfNN5zpyyuu8JedzsrVTizMz3PMqM9451jPXDTaX8u+83DSfJ8lIYT3GgyjJMBjdFWUtZl7zOkqxGFBvcyE1xRjwfqrH+8TxnPJencPtmTEbtfcHAI6SQ6gqPQCwPNqfOgV8amLuF8FIxmvb4qnrYjT7/p5La9z34pwMc9BrKplJxrkOhsnAwe4UkZOVkrA1LJE01VxHZMzk5eVh9erVQd/PyMjQva/y8nLccMMNKCoqwquvvqqEpMxmM5xOZ8D2DocDVqs1kuH6IEkyamsbo/68FhzHIj3dgtpam49epK3icArKvyuqGlBV1RC3fdO5jp6iEncIN9VqCPqd2O1uo8TuEFBba9M919Ue3QTDAHW1tph6FalDk8XldQDcT/5aYyYZTowsB7zv8lyHDY1O5b3yinoA7h5UweagYaP73mboPhx1LgMQx+s3FMl8bXOe77OqutFn3o4crwbgFpTH83eeaJJ5roNh4FnYnSKcDlebnOv0dIsu705ExozBYPDRskTLgQMHcN1110GSJLz99ts45ZRTlPfy8/PxzTff+GzvdDpRXV2N3NzcmI4bTaaGHkRRSti+WxJqwaXNLiRkTuhcR06Vp1JrutUYdO48MhO4BEm58eiZ6waPEWQ0cJ7vP/r6Qmo7qNajxzByrOYYSH8mXuN9EvJwCt7x2zyaIZOB09yf7LTBue9n9z77TGiWaywZr20iprY5fH/PJ6vdpTKy0kxJN2Y9JONcByM304J6mwuZKcF/v8lMU811kwfgjh07hlmzZsFiseC9997zMWQAYOTIkSgpKcGRI0eU1zZt2gQgUG9DSS7URcpoS4PkIVyNGUCVzRThTSdeNWYAtxFCxLv1nvCVMUhTSIvndS39C0nNVj8NhuuY7dq/EXDZwWbkgyvoE+UZtD6CNZusVKr/tr3aL03NbZcMxr9nn5rQthGtgSY3Zu699144nU4sXrwYPM+jvLxc+Q8ABg8ejGHDhmHu3LnYuXMnNm7ciAULFuDCCy9EXl5eUw+XEgHqImW02WTyEK7JJBB9o8l4ZTIRiOam3ubxpAQxPohYWKuar1YBQGeI6r+yLMP1+3fuz/Y9M6ZQWWvDYCB1ZrSNmbZY+6WpSbUY0KFdy9PKNDVN2rWrtLRU8bJMnx6Y9rh3714wDIPnn38eDz74IGbNmgWTyYQpU6bgnnvuacqhUqLAJzWbemaSBqXGjDWEMcMHGgB6iFfHbIKRZ2FzqDwzQdJRR/fPR2lVI4b0bBfwnlbRvFAtF6Tyg5AqjgEcD0OvsTGfQ2vC65nx/T1XNUErAwolEhJqzLz11ls+f+fl5WHv3r1hP5eTk4MlS5YkaliUBCHSdgZJidczE3zhMZDeTBF6ZhxKwbx4eWbc+/EaM9pG0qAeORjUI0fzPZ4lRfNU12MIo8u55wf357qf2qYaSerB22LC97pQqv8muGAehaKXlpO0Tkl6fNsZ0DBTshCulQGgCjNFqpkR4uuZIftRjJkoUr2Vc/HxFGobXbKjAcKBX9zv9Tsz8gG3crQ0M4IoodqT7k81M5RkgRozlLjho1GgnpmkoSZMKwMAPsXlJFl/qCleHbMJxDPTECbMFAqtCsBanhlZluHY+B4gOsFmdwSbG3umZmtDq9FkaZUNkizDbOSQGUKHRaE0JdSYocQFWfZdBKlmJjlwOEWlfksoz4xBVcchEhGw0pcpTgJgo84wUyg4jd5MWkaX89dVcO39EWAYmE69jAp/NVBaTKh+z8Un3bVOCnKsdM4oSUOTCoAprRe1+Beg2UzJQk2j2ytj5FmYg6Q5A76dqQVBv2fGGW/PjGc/jQ6SzaTfSBLLDgIsB55zF+/09cz4NsN0HdgE5yZ3c1vTaVeC7zQw9sG3QrQ8M8UVxJihGTaU5IEaM5S4IPplwVDPTHJQW+8NMYV6iiahGSAyz4wjAdlMPn/r3K/UUIXGlY+4xzL+/wBoZzOZDCzE0v2w//AyAMAwYDKM/SfFPO7WipZmprjCXUm9ICf6iuwUSryhYSZKXBAk3wXQSY2ZpKCmIXzBPABgVAXrIimcR57Y453NRNC7X+HgZkASAElA2s73wEDW1HClSTWwffksIArguwyFafTlcRl3a8WoZDN5f88nPJ6ZQuqZoSQR1JihxAXqmUlOanWIfwnRFM5zhqmsGyn++9G7X9fBTcq/+cpDGGvaGxBmSmNs6HvgLcj2OrDtusA88R9gWHoLDIV/mEmSZZQQzwwt5EZJIugvmRIXqGYmOdFTY4YQTUsDZ7zrzBgiDzNJ9RWQSvcDYGAccj4A4ALrNqTKdaqB1uOmtK9htp8Ek5oDyzm3gzHQGinhIN+ry/M9V9bY4RQk8ByD9pk0LZuSPFBjhhIX/LuiUs9McqCnxgyBPIVHUjgv0ZoZrfYD/ggH3F4ZrqAXjCNnQGrXHWZGwIXGnyHLMmRnI6Y2fIxCvhqCMR3W8+4Gm5IVl/G2dgx+YaYTHq9MXpYVHPVqUZIIejVS4oIQ4JmhxkwyUFMfSZjJU58lIs9MvOvM+IWZdOyXhJj4HqeCYVgwo2dBkFn0MxyH6/cf0PjFYuTJ5aiXTCgb8Q+wGbTHm178BcDeTCYq/qUkF9SYocSFQM8MDTMlA7WN+j0zSpgpEs1MnAXAAdlMYVKzpdoySOWHAIYB320EAIDPLsSXtkEAAMf6ZZBK98MmG7G07mxwmR3iMs62gr9mhqZlU5IVasxQ4gLRzHCst/qqJEXWtJASf4hnRleYKQYBcLDu1pESaWq2i4SYCvuBtaS7/82x+NbeHyeETPdGBjPedE3BcTE7bkZXW0Gpy+MXZipoRz0zlOSC/rIpcYEYM1azt3QR1c00L7Is62plQOA1aoqEQ6msG6IgXyQYDJGFmYSD7r5KfI9Ryms8x0AEh9frzwB6jIX1vP/DIZe7KWW8tD1tBWJcOl0SZFlWqv/StGxKskGNGUpcIE/zFqPXmPHvtEtpWmwOQfleIkvNjqQCsHv/CfPMhAgzSdXFkCqOAQwHQ9fhyussw4ABUCZlQBo9C2z77krj03hpe9oKBlXPrpoGJxrsAhgA+dnUM0NJLqgxQ4kLpM4MxzGKK596ZpoX4pWxmDhdHglDFAJgh0AEwE1fNE8JMXXsD8acqrzOMIyqP5Pk0zxTT3YUxYu6zs/RUneqe06GmRqFlKSD/rIpccGrmWGVhZNmNDUv3oJ5+uqpRCUAJp6ZuKVme/fDc0zI9F8SYjKoQkzqzwLuc1Eb1XQRjgx13Z8jJW5jppAWy6MkIdSYocQF0dPOgOcYZUGinpnmRdHLWA26tidekagqAMet0aT3lhSq+q9YWQSp6gTA8uC7Dgt4Xx0yIwYXxzI+DTUp4WFVbS6OlNYDoGnZlOSE/rIpcUFQhZlMRuKZoZqZ5qSu0QUASLeG18sAkQuABU8IB0hManawfYplB+BY/yYAgO80EIwxcHHlPAuwqPLM0Eym6CC1f4hnhqZlU5IR2jWbEhfUYSYj7/439cw0L3WeGjNpOj0zkfZmUhuriejN5O/tEUv+hGPbpxCLdrlfYFgYBk7W3I/BR8wcX+9RW8PIs7A5gIpaOwCayURJTqgxQ4kLpGgexzJUM5MkEM9Mmk7PjCHC3kykxL06FBEragEwMWxk0QX7N0shHNnufoNhwZ8yFqah54HNyNfcD6cyzIhtFq+Mq7aGvyib1pihJCPUmKHEBeKZ4TkW8KwZ1DPTvNRG7ZnRl5qtDt8wTHyMGXWYiWQeCQc3uw0ZhoOh9zgYh5wHNj035H54VZiJ1G6knpnoUM9beooRKWZ91xOF0pRQY4YSFwRRLbJ0LyRUM9O8KJoZHTVmAIDnvRlAevB2zI6fkaAumqdUn/1jnfvvYRfANPxCXfvhPVlQgiQrniaalh0das9MIRX/UpIU+uumxAVFM8MxyiJEw0zNi6KZsejMZiKeGb1hJuKZCdM/KRJ8BMA8C6mmBGLxHwAYGHqfrns/StNMUYp7xlVbQ/2dUPEvJVmhxgwlLihF81SaGRpmal4UzYxez0zEAmBPX6Y4tTIA/DQzBg6uvT8CALhOA8Gm5ujej7donqxch7SVQXT4GjPUM0NJTqgxQ4kLPtlMBm8/F0rzIEoSGmyRCYD5CAXApDN6vDKZyBhYj/7GxAOuvesBAIY+4yPcj9ozE9/O3m0Ng+r7LaAF8yhJCv11U+ICeZrnOZVnRqCemeai3iZABsAASLXok8ZFWjSPZDPFW4tCCud1Eg5DttWAMaeB7zwkon2oqxk7aJgpJtRGIE3LpiQr1JihxAWvZob1amac1JhpLoheJsViCNkSQI3SAkC3ZyYxRgIJa3Sr/9U9rl5jwXCR5SpwLMlmklVGFzVmooEYuWYjh8xUfV4+CqWpocYMJS6QdgY+mpkYumbX21yQJP3dmym+1DVElpYNRN6bKRHZTIDbmMlgGpHbuB9A5CEmwFf/4+2YTW930UDCiAU5KXFLwadQ4g39dVPigloATJ6so81mOlltw9zn1uPlz3bHbXxtjboI9TKAKswUYTaTKY7ZTO5xcBhlOgAGMrj8XuAyCyPeh09vJuqZiQliBNK0bEoyQ40ZSlwghdZ4jlX1ZorOmCkqb4AoyThWVh+38bU1aiNsMgmoPTORFs2Ls2eGY3CqKXqvDKAqmiepNDO0AnBUDOvVHp1yUzF2YEFzD4VCCQotmteC2XWoAmVVNkwc1rG5h+ITZoq1a7bdKQCIrHszxZdIWxkAUaRmC/EJ38iiALjskGUJkCX05o6gPVcHkTOB7zYyqn1qdc2OZwp5W+KUjpl48NpRzT0MCiUk1Jhpwbzy+e+obXBiQPcc5GZamnUs6qJ5phhTs20e4bDesvqUQCJtMgkABpLOHGmYKQbPjFRTioaPHwCcNuW18z3/r88fhkyDKar9cqrUbEcCivtRKJTkghozLRSHS1RCCTa70Myj8dPMxFg0j3hm9GbVUAKJyjPDRyYAjkeYyfXnzz6GDMBAZhi4+FTkjTk/6OfCwauK5sXD6KJQKMkNNWZaKNX1DuXfyRCOESRSZ4aNuWu23UE8M81/Xi2VSJtMAqrQjG7PDCmaF73HQzi8FQBgPmM2+F7j4pYtw2t5ZqgxQ6G0WqjftYVSXZdcxoyvZ8Z9WTmiDDPZndSYiRWlyWQk2UwRp2bHZiRItWWQKosAhgXfZWhc037VjSYVzQxNzaZQWi30191CqVJ5ZvQuPolEXTRP7ZmR5ch1LzZFACxH9XlKdJoZPuIKwMRIiM6YEQ65vTJcYR8w5tSo9hEMTc0M9cxQKK0Wasy0UKrrnMq/BaH5F3xRVGUzeRYNGdHpXuyqysEiLZwXMYIoocGjo9LbZBJQhWZ0Xk9eIyG624jLE2Liuw6L6vOhUGdmUc0MhdL6ocZMCyX5NDOkzgzjs7g5ozJmvIJmKgKOnHpPwTwGQKo5gmwmT0q9S5R0ecRiCTNJjdWQSg8AAPiuwyP+fDjUqdkO2miSQmn10F93C6WqLsnCTIpnhgXHsspTviOK/kxqz0wyGGotDaKXSbUawLL6dSgkNRvQlxavaFGiKEYnHN4OQAbbvjvYlKyIPx8OEmZyuUTlGqKeGQql9UKNmRaKj2cmCbwXimbGs3gqupkoOmfbHV7PDK01EzneTKbImgISbwYAuHR8b6QrejQeDyGBISbAK2ZuVF1LVDNDobReEmrMLFiwAPPmzQv6vizLmD17NmbOnOnzusPhwIMPPogxY8Zg6NChuPPOO1FZWZnIobY4qpItm0lVNA9ATLVm1J6ZZPA6tTSI+DeSVgaAVwAM6AvvRatFkZ2NEE/87j5mt8QYM+Q69DFmaNE8CqXVkpBftyRJWLx4MZYvXx5yu2XLlmH9+vUBrz/wwANYv349nnvuOSxbtgwHDx7ErbfemoihtkhkWUZ1vVcArLeXTiIhBhV5uvc2m4xRAEyNmYipayBhpsg8MyzDKJ41PQZytF2zhaM7AUkEm1kQVRNJPZDU7EaPENpoYGnHZwqlFRP3onkHDhzA/PnzceTIERQWBr9R7d27Fy+88AKGDBni83ppaSk++eQTvPjiixgxYgQAYPHixZgyZQq2b9+OoUOHxnvILY4Gu+Cz2CSVZ8YvzBSdZ4YKgGOhzhadZwZwG6OiJMIlSDCFeNQRREn5ziOt3+INMcVf+EsgRjUxZqhehkJp3cTdmNm4cSN69OiBF154AbfffrvmNg6HA3fddRduvfVW7N69G8ePH1fe27rVfaMbPXq08lq3bt2Ql5eHzZs3x2TM8HF2M3OeGybHNa37us6TrUKQJDnu5xYpkmdhMxo48Ly3c7YQ4dhcguSjk5Hh/t6aa66TlQa7Cx+vO4jTBuSje2GGz3v1NvcCnpFqivi64HkWDpfbmLFagt8e1FlqVovBR28TCllwQjj2GwDA1GNEwq5bo9HXmDZ5rstkhF7bTQed66ajqec67sbMlVdeGXabRYsWITc3F1dddRXuuecen/dKS0uRlZUFk8m3wVxubi5KSkqiHhfLMsjKSon686FIT2/aJo8HS+t9/uYMXMLOTS/E/MjKtCIrKwUpnhAHb+AjGluNStgMABaryefzTT3XycrWTUfx1aZjKKu246EbTvN5z+5ZwPPbp0Z8XZgMLBpsbqMy1FxLNe5+SizLoF1Oqu4QTsOfvwMuO7i0HLTrPSBhoZ+szEafvy1mQ7P/RsJBr+2mg85109FUcx2RMVNUVISzzjor6PsbNmxAdnZ2yH2sW7cOn332GVauXKl5I7PZbDAaA2P9JpMJDocj4HW9SJKM2trG8BtGAMexSE+3oLbW1qTajmPFNT5/1zc4UFXV0GTH18Lp0bk0NrrHQmzxqurGiMZWXmXz+buyqgFVVeZmm+tkpcIzpweP1wTMb0W1ew45yBFfF6znN+kUxJBzXV7p/i0ZeRbV1fp/Vw07fwIA8F2HRvS5SLE1On3+5lmm2X8jwaDXdtNB57rpiNdcp6dbdHl3IjJm8vLysHr16qDvZ2RkBH0PACorK3HvvffigQceQF5enuY2ZrMZTqcz4HWHwwGLJTYLL1EpzKIoNWl6dEWN3edvp7Npj68FKZoH2T3PRABscwgRja3ObxFyOEWfzzf1XCcrpH5PbYMTlTV2pKsq/ZJu6ikmPuK5IuEilyCFnGu1FkXvMWRZguvwdgAA23lYQr9H/8ckI88m/XVDr+2mg85109FUcx2RMWMwGNCjR4+oD7Z27VqUl5fj3nvvxb333gsAcDqdkCQJQ4cOxapVq5Cfn4/q6mo4nU4fD01ZWVlQA6itQTKZOJaBKMlJkb6sbmcAeGuPRNo52+5XZI/WmdFGrVkpKq9HvxSvR5QUzYu0zgzga8yEPH4UrQyk8kOQ7XWAwQKuoFfEY4sEzq9YIK0xQ6G0buKumQnF2WefjWHDfOtKPPnkkygpKcGTTz6J3NxcDB8+HJIkYevWrRgzZgwA4NChQygtLcXIkSObcrhJC+mYnZ1uQnm1PbmymQLqzEQ2tkBjpvnPLRlx+RgzDejX1W3MCKKk1FZJj6AvE8HAk/5Moec9muaNwtFfAQB8pwFg2MTeevwFybRjNoXSumlSYyY1NRWpqb7dcVNSUmA2m9GlSxcA7lDWeeedh/vuuw+PPPIILBYL7r//fowaNSogjbutQgrmtc+0JI0xQzwopL6HunN2JKjTst37bf5zS0Zcfp4ZAvHKsAwDqznyn7d+z4ynxkwErQyEIx5jpvPgiMcVKf6ZS9QzQ6G0bpLyceWhhx7CmDFjMGfOHMyePRvdu3fHkiVLmntYSQNpZdAuw60hSoZQjCh5wkx+nplI2xn4e2aSIYSWjKjn5biPMeMOQaZaDYqYNxK8xkzo7418r3o9HlJDFaSKIwAYcJ0GRTyuSOH9wky0zgyF0rpJqGfmrbfeCrvNY489FvCa1WrFwoULsXDhwkQMq0UjiJIi8GyfaVZea04kWQZpsqwUzfM8GUccZnL4eWaoSE8TtbFx/GQDJEkGyzIqvUzkBfMAwMDr88xEGmYiISY2txtYS3pUY4sE/zAT7ZhNobRu6C+8hVHb4IQMt9GQleauxdPcVXJFlWeI84SZSNEyKgBODOrv3OmSUO5Jx65V+jJFrpcBVJ6ZMAZypK0MRKKX6TwkqnFFCs9RzwyF0pagxkwLo8oTYspINSp6heb2zKiPTxYREx9dOwMqANaHvwFLdDOxembI96c3m8mko6quLDghHN/t3n8T6GWAwKqjVDNDobRuqDHTwqiucz95Z6WalKfo5l7wSSYToKGZiTDMZKMCYF0QY4MYH0Xl7oJwRDMTTVo2ABh0CoAjCTOJxXsBwQnGmgk2p3NU44oU6pmhUNoW1JhpYRDxb2aqCTxPnqKbNxSjNmaI6JQIQ6P1zBDtKhUAa0OMjU65aQDUnhlizETpmdGpmSHp33oypoSjO9z77jy4yTpXswzjUzjPmKR9mSgUSnygv/AWhmLMpJmUp+jm9l6oC+aRxcoYbWq2Z5FMMbsXYyGIoSbLMt75Zh9+2H5c8/3WDjHyuhUQY8btmaltcIeZYtbMhMlmarDpM2ZkWYZwdKd7302klwEAhmF8Qk2k8SmFQmmdUGOmhUFqzGSmGpMmzERaGagzSEyG6DQzNo9nhngWgp1baZUN32wpwkdrD0Q83tYA8Zx0K3BnBpVVNcLpElFni80zozfM1Gh3G03E6AyGVH0Ccl05wPHgOvSLakzRog41RVIPh0KhtDyoMdPCIJ6ZrDST7syTROPfygBQtzOItAKw+4k/zeJeJIOdG+lNFGnqd2uBtDNol2FGqsUAWQZOVDSgriH6VgaAN8wULiW+wU48aKE9MySLiSvoA8ZgimpM0eJrXNNbHYXSmqG/8BaG1zNj0r3wJBr/VgZA9J4ZoplJ9SzGwbqtEs+BIEqQ5baXvi0IXgFux/YpAICisoY4eGY8OqwwBnKDxzNjDeOZEZo4JVuN+nqk2UwUSuuGGjMtDNJkMivNpCw8zV2LhdSZ8fXMuBcPUZIjCoMpxozimdE+N7Wmo7nDbM0BMeYMHIuO7d0tQg6X1MLmcM9LNH2ZgAgEwDo8M7KjAWLJn+79NlFKthqDRtiTQqG0Tqgx04JwOEXYPALZzCRKzRYkkias7daPJNREBMCKZibIoqr2HDR30cBIOFljw+c/H0a9zRXTfsj5G3gWHXPdxszvR6oAuI1Kqym64t56ejPJsqx4ZkJpZoQj2wFZAptVCDa9fVTjiQW1AJhWAKZQWjf0F96CIHoZk5GDxcQrT9GiJENqxlCLlmeG51glvVpvfyZRkhQtCPHMBDPU1AaSswUZM2t+OYoV6w7i59+KY9qP4pnhWXTwhJmKKxoBuPsyRZsCbdCRzeQUJMUbGCybSZYkOHesAgDwPU+LaiyxwmuEPSkUSuuEGjMtCLVeBvB1ozenbsarmfGOh2EYJdSkVzfjUFX/DWfMtFTPDBHO1tuj98xIkqwYEwaeRYd2KT7vp1miCzEB+jwzJMTEsQzMQVKehYObIFUXA6YUGPufFfV4YoF0cAeoZoZCae1QY6YFQVoZZKW6Fyt1WKc5Q01Kx+wgnYr1hpmIXobnGJiN7if+YEJU9WLbFMbMR2sPYN6LG5SidNFCxhpplpfPPlRzYuBZmI280nQUANJTohP/AlAVYgw+vgYbEf/ymh4gWZLg3PYpAMA48BwwRkvU44kFn9RsGmaiUFo19BfeglAXzAN8b9bNKQImx/YvIW9UOmfr88wQPZDZyMPAhxY3N7Uxs/mPMpRV27C/qCam/ZCQW6TFBNWoz5d0uSYiYCD6tGxAX52ZcJlMPl6ZAWdHPZZYIZ5CnmOUBqgUCqV1Qn/hLQgSZsryhJkYhlG8Ic3qmVE0M76XkynCztnEM2M2cmHFzT7GTBOcOxlbpec7iBYSDoylPg45d5bxLtId1MaMJQbPjA7NDAkzpWroZZLFKwOomp7SEBOF0uqhxkwLgqRlE80MoEqlTcIwkzHCztleY4b3GjPBsplUi60rBi+HXkgxv8o6e0z7cSphphg8M6pMJgKpNQMAaVGmZQP6UrPrQ3hmksUrA3gNM6qXoVBaP9SYaUFU13mr/xIMYRb9pkCraB7gTc/Wr5nxhJlMnLJQ6xIAJ9iQkyRZOYeqGD0zxEhw6Mzw0tyHxxDyNWbUYaboPTN6wkzBaswkk1cG8BrX1JihUFo/1JhJUt7/bj/e+OIPn0VF3TGbwCdB4TxBaWfgezlFms1ECr6ZjZyyEAUvmtd0mhliZAFAVW1sxowzjgJgtTGTl21RPBHRNpkEoKtFRrAaM75emUlRjyFekHMx0Y7ZFEqrJ7rKWpSEUtfoxJpNRwG4BaPXnd8PDNQCYO9ilQz9mURJWwBsirBztuKZMfLKQh2unYH/vxOBXZUyHqtnRoijAFhtzHAsi16dMvD74aqAVO1IIN9haAFwYMdsWZbh3P4ZAOKVsUY9hnihhJlox2wKpdVDjZkkpKzapvx74+5SZKeZcc6oTor3Re2ZMSRBfyatonmANx02Us2MRSUATobUbJvKmKmsc0CW5aiL0jkVAXB8jRkAmDNjIGobnMjNit6QMOjQzGiFmaSq45CqjgMcnxReGUAlAKaeGQql1UONmSSkvMptzKSYeTTYBazeeASNqjL/6voyydDSQKtoHhB5nRmbyjPjFQCHDzMlugKwOswkiBLqbK6oQzlxqTOj6sukxmzklfo80aKnaB6pM5OiypoSDm8FAHAd+ieFVwagAmAKpS1BH1mSEOKZGXpKe1x4ejcAwA/bjwPw9coASRJmUjQz/p6ZaLOZvAJgSZYhSYEGTZOGmRy+449FN6MYM7EIgD37MCbA4+A1IoOPTyvMJBzaBgAwdB0e9zFFC0dTsymUNgM1ZpKQco8x0z7TjAtO64rxgwuU99SZTACSonO2EE4zo9PYIEaDxcT77EvLUGvKbCa1ZwaIXjcjSpLixUpEmCkeeI1Ib8q9P41+AmCprhxSxRGAYcB1GRL3MUWL1zNDb3MUSmuH/sqTEBJmap9lAcMwmHlObwzsngMAyM/2deHzSaGZCZbN5NHMOCMVAHNhWzU0lwAYiL7WjE9ozCVBjrI5qDebKf4eB5+q0kFCfA1+mhnhsNsrw+X3AmtJj/uYoiXDU2/H35tJoVBaH1Qzk4SQMFNupttw4VgWc2YMwK/7K9Cva5bPtkkRZpK0BcBez0zkYSb1vrS8Tup9JtqQI20WCNF6ZvyNLpcgRaXnIPvhExhmAtzXFMf6jk+WZUUATIrmEWOG7zos7uOJhQlDOyAn3Yz+3bKbeygUCiXBUGMmyXC6RKXSb26Wt+iYgecwok9uwPaGZBAAi9pF8yKvAOwVADMMA55jIYiSprHiKwBObAXgAM9MlJoZf2PGGaMx4y8Ajgccy4ABIMNjJPqNz+4UIXk8SilmHpKtFmLJPgDJZ8yYDNq/GQqF0vqgYaYko7zGHcKwmLiACqtaJEOYSfBoK3j/bCZjdF2zLSb357zNJpMjzEQq61bFIcwE6A+/+UOMt0RoQRiGCdkig2QyGXgWRgMH8cgOQJbB5nQBm9Y+7uOhUCgUPVBjJslQ9DKZFl21TJQiZ0kYZoq0a7a6NxMQOoSmt9HknsOV+P1Ila7jBx+X22NUmOMuRhdtmMlfCB2tRymRnhkAIVtJ+GcyuTwp2Xy35PLKUCiUtgU1ZpKMckUvo6+vjTfM1HzZTMGK5kVaAZhoU8wej06oGjo+2UwhmlE+++FOPPPBrwEZSZFA2iwUeCrrksJ5kRIQZoqy1kwis5mA0P2ZSCZTqtkA2WmDeHw3gOQLMVEolLYFNWaSjLJqr2dGD0lRNI9kM3H+2Uz6jRlZlpWwi9eY8YSZNLJqXK7wxozNKcIlSHAJEkoqG8OOIRjEECrwZJK5BEnxUESCy88TE216tlZvpngS6ppSe2aEol2AKIBJzwWb1TEhY6FQKBQ9UGMmyVBqzGTpNGbCdJduCpTeTAGeGRJmCj82h0sEMVnMJt8wU7SeGbURVXwyFmPGvZ9Uq0HRzVTWRq6bCQgzRWvMJNgzo2hmNIxIdZNJUvWX7zos6vYOFAqFEg9oNlOSEWmYKVzZ/6ZACNLOIBLPDAnlMIxXaxMsU0uWZV0CYHUY50RFQ9gxBMPbM4pHVpoJdY0uVNU50DkvLaL9BAiAYw4zxafOjGvfT5Aaq8Gm54LNyIOVdXtfQnlm0kwMhKO/useRRFV/KRRK24QaM0mEJMsor3Y/8esNMxmSQQAcpJ2BugKwJMtgQzy9+6dlAwiaVeOvDwpqzKjCOsUVsYeZzEYO2WlmHC2tj0oE7C/4jVkAHAfPjHjyMOw//NfntdsBVGSkQDoOoNNEn/eIZ6azdBRw2sBY0sHm9Yh5HBQKhRIL1JhJIqrrHBBECRzLIDtdX9XSpNDMBMtmUqUOu1ySkqqthX9aNqA+t9DGSzBDTu2ZKY6DZ8Zs4pDl+V6iqQIcKABu/mwmocgt4GVSc8BYMyDXlEF21COHawB2vgkHWwnjiBlgPNWdG+0CRhn3Y3jZJgAA320EGIZGqykUSvNCjZkkgoSYcjLMAa0BgpEUxoyoXWdGXRDOIYi6jBl112el71RA5Vwx5N8EteejrMoGQZQCxqgHtdco29MbK5pmk/ELM7nPKy6emRO/AwCMg6bAOOBsAMCz72xAl/L1OMuyG84dn0OsOArLxBsAlsfg0s/QI3U3ILs7ZJtGzIh5DBQKhRIr1JhJIsqqItPLAGqxZhJ4ZvwqALMMAwPPwiVIcDpFwKr1aTd2v7Rs9/60w0xalXS1UHtmRElGWZUNhZ70ar3IsuxtgGnklEaflVGEmeLmmYlTNpMsChCL3dV7ucK+3tcNVqy0DUevQQPQ6eAKiMd2ouGTh8AwLHo4TkCSGZR3ORs9zrmcemUoFEpSQO9ESUSkadmAKn05Cbpm+4eZAK9uJlwast0vLRvwhlFEf2PGX0OjI5sJiC7U5JNlZeSRlWYGEF3hvLgVzXPFx5gRyw4AohOMOQ1sVgfldeK9Opk9GNbp88GkZEOuKYFUfQL1+P/2zjxMivLa/9+qrl5nn4GZYRPZh2VgBhmEsIkgElyjMV73hYjeXORGo4I/jcFoFsW4xxiXuKHRuGHcrooalwgIKKBhk30d1tl7r3p/f3S/1dXd1d1V3T3TM3A+z+MTpqu6+u13Ol3fOed7znHh0ZbT4B40g4QMQRCdBvo26kQcSkPMdI7ZTPpTs4GIbyZR9ITDUzlOTZopYgBO4ZlJaACOfnxfGiZgLrIEIfReuJepIY3GeVlrmhfeb1umYiacYrL0HBpVWq0t97d0OxGu8xZC6jcG0oCT8Vf5fGwNViIvPGSSIAiiM0Bppk6EWpZtsMcM0EmmZofFhmRJHJlJlVLRi8xEok764sVmFeEPhJriMcbiep3ERoPSicxovTyCIKAk365e2+0LmrqpZ61pXpamZqtiptewqMfVCrnw64jOQjhPmwsAOLTucwBBdZwBQRBEZ6BdIzN33HEHFixYEPf49u3bMWfOHNTW1mLChAn47W9/C4/Hox5XFAUPP/wwJk2ahJqaGlxzzTXYvXt3ey61U3CwIY00UycYNJmomgkwPjnbozHZctSoUwKPjCvcXI9p1qCF34z5wM50GufFjliwWS3Id4YHTpo0AWtFGJDbaiYW9EE+sAUAIGn8MgBQmBeJPmlRFKbuB0VmCILoTLSLmFEUBffffz9eeeWVuGMNDQ249NJLIUkSXn31VSxatAgfffQR7rnnHvWcxx57DC+99BLuuusuvPzyy1AUBT//+c/h9/vbY7mdArc3oDYk617sMPy8zpBmStQ0D4h0AU6VUuEmW4dOaXYiA7D2hqp3fS4W+laGmtvtP9oGxWRqSC9ilK4JmIswLoZyOZtJrv8BUGQIeaUQCsujjlWGxzbEjoBw+yIjHCgyQxBEZyLrYmbr1q24+OKL8eqrr6Jnz55xxxcvXgxJkvDAAw9g4MCB+NGPfoR58+Zh3bp1YIzB7/fjb3/7G+bNm4dTTjkFVVVVeOCBB1BfX48PP/ww28vtNPBmeYV5tqjoRCoiU7NzOWhSv2keECnPTscAnKjsnN/MnfbIPuml2bhY6N09HxZRgD+gmB5D4NWJGHEx02Cy10wwRoT50jQA+7MhZtQU09C49FyPMn0xwxvm2W2WtErcCYIg2ousfyMtX74cAwYMwDvvvIPeveOHz3355Zc47bTTYLdHmsJdcMEFeOONNyAIAjZu3Ii2tjaMHz9ePV5YWIhhw4Zh5cqV2V5upyFSyWQ8KgN0rjST3g3OuGcmXjRIkn6lVkCO9FmxqqXp8dfnYsFhs6jRhn0mU016zfzUXjOZRmb85sUMY0wVd7YMxhkE94bEjNRzWNyxivBeHWr0RAnJNg9PMVFUhiCIzkXWv5UuueSSpMe3b9+OadOm4Q9/+AM++OADWK1WnHbaafjf//1f2O121NfXAwB69OgR9bzy8nL1WLpkapiMhadV9NIrZjncFPorv6LEZWqd/OYfVJSsvz+jcDFjs1ni1sAb5QVklnR93rDYyXNK6nk8qqMoLGqv1dezWtQ+Ngzxv18u8Bx2CT2752Hv4TYcaHBDkrobfm9+TRSIX79b2NPU0OoztedcGPBhlX7Z/O9MW87tdEhp/c6Zzw3l8HYAgL3PMIgx1ygrcsBhs8Drl9HQ6kOPslBvHv47yndac/ZZOxbJ5vcIkRza646jo/falJjZs2cPpk2blvD4smXLUFpamvQara2tePLJJ3HGGWfg0Ucfxb59+3DXXXfh0KFDWLRokWoEttlsUc+z2+1oamoys9woRFFASYm5hmlGKSw0bthNRLMnFMLv27PI1Dpb/aEbpCyzdnt/qVDC4qKk2BW3hsJwXxZRsiRdH4++dCvNV88rzA89V7CI6h4XFjphtYXEQJ7LCrvVArc3CKfLHn/9cKl4caET/S0iVm44iCMtflP7xNv4FxU41Of1riwEALR4gqauxRCKNJUVhyIfsmL+d9Ya/pwAQPduBWmlmto2rwcYg7W0B8pOOEH3nJ7d8rFtXxNafYq6RsHSAAAoynfk7LN2LJON7xHCGLTXHUdH7bUpMVNRUYH33nsv4fGioqLULyhJ6NevHxYuXAgAGDFiBGRZxi9/+UssWLAADkfoBub3+9V/A4DP54PTmf6mKApDc3P6wwb1sIRvss3NnrjGbmbZXd8MACh0SGhoMF5C7G4LRXT8QdnU87IJ97C0tXrRYIu+uTIldKyp2ZN0fa3ukLlbDgTV8wKBUFrD7fajudmj7nVTc7jyTWGqT+fwkTYUO6M/zq1tPvWapXkhcbx9b6OpfTraFHotEUx9nj3sUzp41G3udxX2nHD94fEGTf/OGltD70kA0NLsjvO7GFrHpm9D16is0n19i0VEz+552LavCVt2HcWgniED9YHDrQAAmyTk7LN2LJLN7xEiObTXHUe29rqw0GkoumNKzFitVgwYkNmE3MrKSgwaNCjqMf7z3r171fTSwYMHcYLmr8aDBw9iyJAhGb12e/lKZFnJ+NoHjoZumqWFdlPXEsDnF7Gc+WbksGAREL/HvNrK65OTro+X/Fotonoen7LtDyrq/xlkWYEv7DWRLIIamfD6gnHX534Xi0VARbh3z77DbQgEZMMiwB2OhNitFvX6heE00dFmr6k9574hXlLu9SffEz084Yo3qySG+/uYN34H9qwHAIg9hiZ8/Z7d8wEA+w+3qee0uAPq+nPp0TpWycb3CGEM2uuOo6P2usMTh3V1dWrlEmfz5s2wWCzo3bs3qqqqkJ+fjxUrVqjHm5ubsX79etTV1XX0cjuEoKyoU5jNzGUCItVMCmNquqej4U3z9McZhD5iqSp3dKuZxORN86wWS8QArFfNFH5NmxQyAAsA2rxB9aZsBL11lYZTZ16/rIowIwRiDcBpVDNlWpateJqhHA31bLL0rEp4Xq/uoTSStqKJR5aoxwxBEJ2NDhczs2fPxu7du/Gb3/wG27dvxxdffIF77rkH55xzDkpLS2Gz2XDppZfivvvuw8cff4yNGzfihhtuQGVlJWbMmNHRy+0QjjR5wViomVphni31EzRoK4hy0WtGUZgaG9ALBdoMVDMxxjRVQ/HjDBKKmahqpsSl2TarCJvVgrKikAgx0wlYr8rKbrOoFT1mSr15xVWeps9MuiMR0hUz8v6NAACxtDdEZ2HC83hk5kBDpJmlWs3kpGomgiA6Fx3+rdS/f388//zzuPfee3HOOeegoKAAZ599Nm644Qb1nHnz5iEYDOL222+H1+tFXV0dnn76aVitx+ZfhNoBk2Y9ENqbWlBWVPHQUWiFRrJBk8kaxAVlRa1Q0hs0GRui1Lbz5+foihnecTdcwtyzWx4ON3mx74gbQ04oSfHOQuhFZoBQr5k2bxANLT70Ct/4U6FGZrTN/oKKukeGrpHhxGx5b2QeUzJ6dgu9p4YWH3wBGXarRe0z46LIDEEQnYx2FTMvvPCC7uMjR47E4sWLEz7PYrHg5ptvxs0339xeS+tUqDOZTKaYgGgBkYvGedoxAnqzmXjr/mRN8zy+yDG7TtO8uEGTUX1mwmJJJ2XDo0FcLPQoc2Hd1iPYf9h4ZEZvzAIAlBQ4sOdQm6kuwFxcaSMb/rBQMEokMmNetDLGENy9DgAg9YrvL6OlMM+GPKcVbZ4ADjZ40Kc8H24v9ZkhCKJzQsX2nYB0pmVzBEGIDGTMgaFNK2b0pmbbpdRpJp7KsdssqukX0DbNSzBoUhLVydF6752/JhdUvF+KuTRT/JgFQNsF2LiY4eu2WyNeH7MjDXiqKp25TMrRPWCtRwCLNW64pB6VpaHP44Gwb6aNPDMEQXRSSMx0ArgXwaxfhpOo7X9HwKuMBIR6+cRis6UeZ5AolZNo7pRhz0yMv6RnWMzsO2K8RF+dGRWztlKTIw0UhanCz6oRYWZNwOp7t5r/v25wZ6gk29JrGATJnuLs+BlNfHYYzWUiCKKzQWKmE+CNSYeYJdFAxo6AN7uz6KSYAG1kJvHaImIm+iYpJfDDqCLFIqom4dj3rjCmmVIdTjN1C92cG1p8hquQeNTIGZdmCg+bNDg5W/serJJoeGZVouukE5kJ7lwDAJD61ho6n4uZAw2xkRkSMwRBdC5IzHQCfAkiE0axJqj66Qh4j5lETY2MeWa4LyX6/XMxI8eUnBuJzGh/5oIqz2FVo1+xQxT10FZZ6RmAgUgTu1RoIzBaMWM+zZSeAVhxN0I5tA0AIPWtMfQcPqPpwNHQjCa+Vl6NRRAE0VkgMdMJUD0jaUdmIo3zOhp1yKROignQVDMlSaeoZdlxYiY8ETxWqGgqeniEwh8bvdGIJ21KpmcZHziZ2jcTXWUVHY3gN3S3wQgPfw8WUYBFFNX+O6kGcMZdJ81qpuCutQAAsXs/iK5iQ8+pLItEZniKSUB0+TxBEERngMRMJyDTyEwu00zJGuYBkRSPz5+4p4peLxfASJ8Zixr5iUtFBSI3fa2pOGICTh2Z8WimWsf+bngXX17hk4rYiEokzWTud6Z9X2aQ1RRTjeHnVJSExEyLO6Ca1J12KWo/CYIgOgMkZjoBqmcm3TRTDg3AwRRpJh6BUBiLSxdxElUMJXpfwWB8ZCbeV8O7/0avq7QwlB5qbvMnekuRdfkiEbNYc7PTERlJwFNtyYgVM3Yps8hM7PtKBgv6EdzzHwDG/TJASLgU5YdnWu0LzQ6jhnkEQXRGSMx0AnwJDLBGkZKUJ7c3RiMzQGLfDPfMxJpsI1VaLCqqw4WKts9MoshMbBNBvsc8GpSMRH4ZIBKZCa0/tSDxB6NFiBqZSbeayWJc+Mp71wOyH0JeKcTSPqZerzIcndm2PyRmqGEeQRCdERIznYBMIzM5TTMpvJpJ/6MkWURV6CQyuyYSDdGjGiJiRlvRk2g2ExdOsREM/hpef2oRkUzMSBZRTXEZ8c3w/jBSWHwZ6YysRzANAzAvyZb61pruMF0R7jWzbV8TAKpkIgiic0JiJscojEUiM2kagK0W/eZyHQHvM5PIAAwgZRlyYjETuab2velWM8VcO7YsmxOJzBgRM2EvTwLDK4/OeAz4ZgJxkZk000yaUQ5GYExRzb/SicZTTBxe0XSoMdRPhxrmEQTRGSExk2O0N7NMIzPBHIwzCCrJ00xA6ht3KgMwECNmZB0xI8emmaK7/3K4L8dImomnj2KrrDg85cKnSScjTsxI6fWZ0abYjKAc2gHmbgSsDlh6DDH1WkDEBMyhyAxBEJ0REjM5hkdlBMGcqVOLlKDXSkcgp2iaB0RSKikjMzEGYFEQVJHE3xvTNsNLYgD2qQbg2MiMmTSTvsji8E64RtJMsd2I0+4zY9IAHNy1BgAg9R4BwWI+qsIjMxzyzBAE0RkhMZNjuF/GYbOY9jNwclnNlKppHhARFAk9MwkMwED8qAZZYeBe4GRN81QDcJxnxkyaKXnJPE8ztZlIM1lVz0yG4wyMihmNXyYdyoud0H4qqZqJIIjOCImZHMMjM+k2zANyPJspRdM8ALDbkncBTm60DUdmwhGg2LEAqdNMMZEZaxoG4ESeGYfxXjOBmPRQJDLTfuMMlJbDUI7sBgQBlhNGmnodjlUSUVbkUH8mzwxBEJ0REjM5ht8w7WmWZQPa5nI58MzIkc62ibClmJztSWK0jS0714oZySKq1w7ERH0iBmB9z0xQVlKKv0RjFjhq4zxD1UwJSrPbcZxB4IevAACWysEQHQWmXkeLNtXkou6/BEF0QkjM5BhvhpVMgGacQS47ACeJFKTyzCQz2kpidNSJe08kiwhBEFKXZsdVM0V+ThWdSZlmchivZvLHVCGpU7PTjcykEDNMURDY+Fno3Koppl4jlooSp/pvmstEEERnhMRMjvFl2GMGQEITbEcgm6pmStRnJuyZSRaZkXlkJrp/TCLzc2yTOo5FjKSmUlU0pTQA2/l8JvPVTPZM00xS8s+LvGcdWOsRwJ4Hqd8YU68RizYyQ9VMBEF0RkjM5JjIDbNre2bSjcwEgoqaHtMTM9aYYZOxkYnEBmD9aibAeEVTogGYHHOemQSzmUwKUKODJv3rPw2dN3giBMlm6jViqdSmmUjMEATRCSExk2MyHTIJ5DbNFDTRNE+vcsejiY7oRadie+jEiZlEs5kC+p4ZwISY8RlrmmfGMxNXzWQ6MpO6z4zSegTy7nUAANvQU0xdX4+oNBMZgAmC6ITQn1k5xpuNaiY1OtHxBmAzaSafP15saU22etOYpRhPTHyEIzLIMigrqvhRB03q7KvR+UypPDNOU31mOq6aKbDxM4AxWHoOhVjcw9T19ehW7MTIAWWwWsSMRDdBEER7QWImx2TDM5PTNBOvZjKQZtKLzHi5+TdB9EPtoROMNgDzx7U39UBQI2bCkRk9kahGZlIMiIykmfTXlmcmzRTT7K69qpmYEkRg4+ehc4ZONXXtRIiCgF9eMCor1yIIgmgPKM2UY1L99W+E3DbNS90BOFnr/lTlz5aYFJqaZrFGG4CB6IqmZG3/jTbO86TwM6lpJiNiJhAtQuxSdATJKLFG4liCO9eCuRshOAshnTja1LUJgiC6KiRmckw2m+blYmo297IkSzPxqJNeNZMnSSUTEC/UYtMsoiBEPEMa30ykA3D8vvL1pJqLlLo026peJ5WQjDXuascZKMxYelA7yiFRZCawIWz8HTIJgoUCrwRBHB+QmMkxkXEGmTTNi7+ZdxR8nAHvB6MHjyLoiQdvimGOsUJNrzRZr6KJe1HsSQ3AiSMqsqKo10tkAHZqZkl5Uvhm+HpivT6x606GrDBw2aMnZpTmg5D3fA9AyLi3DEEQRFeCxEyOyUZptjWHU7PNDJrUM7sm6/4LaPxAQf1qptC/uSdHm2bi1UzplWZrjyX63QjeFjhtofedygQc8cxY4tZl1AQcO8oh7viGfwEALL2HQywsN3RNgiCIYwGKQ+eYrp5mMlbNlNozk8hka5WiPTOx06cB/fLsSDVTEs9MEgMwX5dkEdX95Sgth+Fb+TqCW5bheld3POSfltI3E+uZEcPdiwNBxfDk7NhRDlFraqqH/z9LQ68xLDvGX4IgiK4CiZkck5U+MzFdcjuSoKFqpsQdgNWKoVSRmVgDcFRkRow6pn0tbTqKyUEENn2Ouj1fYKM0CF5/ZcI16/llmK8Nvm/fQeA/HwFySLz0Eg/h5wX/gtszGkBhwuvFVjPxfweCSkrvjvqeNO9dO2GdKUF4PnkCCPph6Tk07QnZBEEQXRUSMznGm8VxBrnxzKSemm0oMmM365kREdy1FoKzUHc+k+qZkUQwRUbwh6/g++YtsJbDKAZwZf5+vOcdmHDNsWImsHUFvF8+D/jaAACWHlWwDpmE5n89i8HWerSseQHsxBsgJPAOcXGlrb6yWS1o8wYNVzQl6jHj/+ZtKIe2ATYXHKf8HIJA2WOCII4vSMzkmEhkJgMDcJZLsxljeGnpDygrdGDmySckPdfMOANdz4wv+fuXYoQav6FX+nbC838vAZIN3cQLsRuCekxhLOKZOfA93B+8DqWpHgAgOIvgU0QU+BowuuUTAGN1X9fri1RZKU0H4P3Xk4AchFjSC/aTfwZLn5EQBAEfrzqK01reRMHh7+D79wuwT7w8KmrCUSMzkBHY8Q2k3iM0+2IuzaSNSsn1P8D/7T8BAI5JV0DMLzN0LYIgiGMJEjM5Ru0AnIVxBoEsGYD3H3Hj49V7AACjBpahR1lewnPVpnlGBk3qRI70IjPM1wbPJ3+F1Gs4JMsgAJH3FggqEMAw7OjHoZODfswQP8YaTIub31Rl3Qvhs0+ggEGw58NWcwasw0/FrjXfo9fqRzEosBHBnWsg9a2JW1dkmrkI779fAOQgLL2Gwfnjm6KiL00FA/DC/om4suALBDZ8CsFZCPuYn8Rdj6fA8lf9Dd7672GpGIR8aTKA1CXi6jViyruZ3wPPp08AjEEaOB7WAScbug5BEMSxBsWjc4jCmHojc2RgAOY3NzlLkZlWT2QK9NKwqElE0EQ1UyCoQFGiBZfexGz/hs8g714H3/K/o5t3Z+h1NEJljG0bCn0HAKsTkOzoqezDZPvGKDFTKrbg8rwvAIRu9HkXLYJt1I8hSHYI3frhU+/Q0Ot/8SxYOHWkhVdZDRW2hcqdLRIcEy+PSyO5HBLWBE7EhvKZobV/8xYCW5bHXS8QVDDMugdS/fcAAPnAD/iZ8jZcgtdwNVMwJjLj/eolsJZDEPLL4Jh4maFrEARBHIuQmMkh2ptYNsYZZKuaqc0bETP//m5/lLiJxUw1ExDf8TY2zcQYQ2DTZ+rxqj1LYIdfTaHJAS/OcH4bum7tWbCPuxAAcKbrG4itB0Ov4fFgdv6/kCf6IXbvD8eUqyHYIsMS7TYJ73tqcIQVgbkb4Vv+StyavX4ZDsGPH3lDa7HVnAmxKN4wzLsAb3bVwFZzZui5Xz4PpfWoeo6iMDA5iJ+4VgIApP51EBwFqFAO4vqCD6G0NSXcOy3aSq7g7u8Q3PwFAAGOqXMg2FzJn0wQBHEMQ2Imh3C/jCAkbk9vhNheLJmiLTP2BxR8vnZfwnPVpnlJPDPa9xY7iyjSATgkeOT9m8CaDgBWB4SC7rAHmnBe3kpVzAxoXoUSixs+WxFsI6bDOnQq9tv6wibIOGHb62CKAny9GL2lBrQyB5ynzYVgiZ707LBZEICE13wTAAgIbPocwT3fR53j9QVxhvNbOJU2CEWVsNWcofveXOH5TB5vELYx50Ls3h/wu+H97CkwFo4UyQqmODag3NICOIvgmHw1nGctgFvIQ0+pESd+/9co8ZMIrWfGv+ad0L9HTIfUY0jK5xIEQRzLkJjJIZHuvxZd06hReNpBYSwujZMObeFIDI8Wfbx6T0JzsWxgnIEgCBHfTExKxRvTZyawMRQJsQ44GY6p14BBwDj7VlS6N0Nua8KwthUAgP19ZkCQbBAEAatLZsLLrChs2wXPu/fCuutryEzAq8FTIeaXxq2HVyht8naHdfi00Do+fQK+b9+G0hyK7tiad2OifVPo/ImXxwkijjqfyReEIEpwTp0DWGyQ965H4D8hX4+/+ShOd64LXbfupxBsTlhKeuHjsotwVM6Dw3sY7rfuhnxgS8I9BCJipicOQd6/CRAssI38cdLnEARBHA+QmMkhvGlbJg3zgIgBGMhOqqktHJkZW1WOwjwbGlp8WL3pkO65QYUbgJN/lOwJyrM93Ghrt4D52hDcHkrFWKumQKocjEM9JwEAftT6EY589AxszI/dwVK0lkd6qQQdpXjTPQYAIO/fCAB42zMa+6Q+umvhKS1ZYRBHnwexqBLM0wz/ytfR9vItaHvzt6jevwSiAOwvrIbUa1jC9+WKmZwtFleqqS/fin9AbtgLZfXrcAhB7Ax2g23IBPW5fmcZHm45HW5bGVjbUbj/+Qf4176vRnRi4WKmNhhKs0kDT9YVawRBEMcbJGZyiE/tMZNZUZk2xZON8mx+Yy7Kt+HU2l4AgA9X7gbTGYhoZJwBEGnjry1DDsqR+UdOu4TAD1+Fyp9L+0Ds3g8AcLTf6dgXLIaTedD6ny8AAG+5T4LVGtkzqyRiuW8gDrkGAADaKmrwqXeY7pBJILoRno9JcP3kN3BMvhqWXsMBQYByaBsKgkfhVmzY3Tt55EMbmVHXM+xUWHqPAOQAPP/3IMQdIUPwW/5xUT1gbJIFDUo+lp0wG1L/sQCT4VvxCjwfPATmbY17rYCsoFRsRb/AD6Hnj5yZdG0EQRDHCyRmckik/DezyIw2xZONxnncAOyyW3FKbS9IFhHb9zdj697muHPVpnkpxIzepOqo+UdWSyTFVDVFTbtZrDYsbpsIOfxR3Sb2xQ/BHjodgAWsLD8Xjun/g/1VFwIQdEcZAIAoRo55/TIEmxPWqslwnXEz8i55APYfXYpd1gF4oW0iLPlFSd8Xn5zt1pimBUGAY8pswJ4H1hKKaC33DcBBsUJ3TzyKFY5p/w37xMsBiwR511q0vX4H5EM7os4PBGRMcWyACAZLr+GwlCXvAUQQBHG8QGImh/iy0P0XCN08s1nRxNNMeU4JhXk2jBseugl/uHJX3LmRaqbkHyVuAtZ6ZniPGbvVAhzZAeXoHsBihXXQePUcySJir1yKjy1TYO81BB8jlKbRm83kU6yw9q+DXxajXlMPdT5TzLBJ0VUM24jpeNd+BtYHeqccM6GmmWIGTYp5JXBMuhIAoEgOvOMeHTccUjtNXBAE2IadCtc5v4ZQVBFKO717L+TDO9Tzmb8N4+3hqMwo8soQBEFwSMzkkGxMzOZEBjJmwQAcjjLkhaMOM8aEvCerNx/C4UZP1LnBJE3zGGPwff0aPEsfQ4EUeq8+HTHjsFsQ2PgvAIDUbwwEe6RJnzUc8VmLKvS68vc4JBeEHteKGWv0oEkumPQmZnMik7P1B0R6DXZm5mLGH1DiUnzW/nVwzrwRR06eixbmjJoTpV2ftlzd0q0v8n6yEGLFQMDvhvvdRZAPh3rtlB9aCbsQRJO1eyglRhAEQQAgMZNT9IYZpkts2/9MUCMz4Rt17/J8DO1bAsaArzcejDo3mWcm8P2H8K95B8FtX2O6fykEsCjPDBczRTYFgS2hKiXr0FOi35c6dynSARjQj8zwPizqKINkYsbKxYx+wzpuTHam+N1op33rTc6WThgJt6tH1Do5tgTjDASbE64f/wpieX/A1wbPu4sgH9qO3ke/BgBsLxmXUfUbQRDEsUa7ipk77rgDCxYsiHv8q6++wvnnn4+amhpMnz4dTz/9dNRxn8+HO++8E+PHj0dtbS1+9atf4ejR1H04uhq8z0ym1UxAdhvnuWMiMwDQv2doInRjiy/qXLXPTEyaST6wBb7l/wj/JODE4Fac5vguOjITfv8jpe1A0AehqBKWysFR14kVaX6dYYuRqdn8nMiQyURwAelLIGYiUbPkkRlRFNQeObGpJk5AFVfR67EnKFcHwoJm1k0Qu/cD87XC/dbdcMitaFScOFRcnXRNBEEQxxvtImYURcH999+PV16J76y6bds2XHvttZg6dSrefvtt3HjjjXj44Yfx4osvqucsXLgQX375JR555BE899xz2LZtG+bNm9ceS80p2fLMAJrJ2RmKGcYY2jyhmzJPoQBAvjMkbFpiugFHBk1GIgWKtwWepY8BTIbUvw6OyVcBAH7sXIO8oxvU87y+IIZZ92CCHKr2sVVNjos4xA7RVCMzGgEYOzWbRzqsySIz4SokT6o0U4Jp3lrUiiadyEzUmmMjM1LiaeIAINhcIUHT7URACZ3zmXcorFb9njcEQRDHK1kXM1u3bsXFF1+MV199FT179ow7/vnnn8PlcmHu3Lno06cPZs2ahUmTJuGLL0JltwcOHMCSJUtw++23Y8yYMRg5ciTuv/9+rFy5Et9++222l5tTsppmkrKTZvL6ZSjhEuw8Z+SmWeAK/bvV7Y86PxjTNI8xBd5PnwRrOwqhqAKOyVfDWjUZ2/JrIQrA4J2vQWmqB/N7UL7pVVxb8AlczAOxpBesVVPi35c6RDNGzERFZixRx1TPjIHIjF6aSWFMjdg4DZTNO+3hiiaf/tiHiLgylmbSItjz4Jp1EywVg9BsKcEy3+A47w1BEMTxTtbFzPLlyzFgwAC888476N27d9zxsrIyNDY24p133gFjDJs2bcLq1asxatQoAMDq1asBAOPGjVOf069fP1RUVGDlypXZXm5OyW6aKTuTs3l0QbIIUWIg32kDALS4YyMzYQMw9618+w7k3esAixXO6XPVmUibKk7HtkB3WBUfPP/3INpeux3dD6+GwoBNeWPg+slvooy/HKsmzSTLiiq04kuztWLGgGcmiZjRpp6MCM3YxnmxqNOuLQnSTEH9yAxHcOTDefb/w1ulV8PDbHFVUQRBEMc7mXVr0+GSSy5JevzHP/4xVqxYgZtvvhm33HILZFnGWWedheuuuw5AKDJTUlICu90e9bzy8nLU19dntDYpyzcBfgO3JJlLlAxf+CaW57RmvDb+1zoDy+hafMRCnsMalaYpLgj9Plo9gajrcwOww2YBDm+Ff/WbAADX5Ctgr+irnudw2PFM6xTc1u3/4GgK/R491mI8eWQs+g+swziHQ3c9PB0UlJnqlwEAp0NS18EFR1BWIEmiKh6cdkvCvXCG/UD+oBx3TsAder4oCHA6pJRm2zxnaI2+QPy1gIjgs9ui16OuIaAY+p3xlF7sdbJNpp9rwhy03x0H7XXH0dF7bUrM7NmzB9OmTUt4fNmyZSgtTd5e/ciRI9i7dy/mzZuHKVOmYP369bjnnnvwyCOPYN68efB4PLDZbHHPs9vt8Pl8Olc0higKKCmJ/8s/GxQWOlOfpAMPopQWuzJemzMcHbDbbRlda/cRNwCgMD/6Or1Z6Ibe4gmguNgFQRDAGFNvsKWleQj+ZwXAGPKGTUDFj6L7oBQVOtHMXFhZ+VOc6v0IjhOG4xP3aGw9sA8nFTkTrlkKp3AUxtQ5TgBQ3q0AYji1VVriBRC62ZeU5AHhx4sLE1+3JPw7Y4j/XLT6w2LIIaG0ND/pfkVdSxB1X08KdyvOd9mjjncPj7PwBxVDvzMWFlXFSfYrm6T7uSbSg/a746C97jg6aq9NiZmKigq89957CY8XFSXvlgoAt912G3r06IH//u//BgAMGzYMjDEsXLgQl156KRwOB/x+f9zzfD4fnM70N0VRGJqb3Wk/Xw+LRURhoRPNzR7IaRhvW9tC71MOBNHQ0JbZYsLpl8Zmd0bXqj8UaqPvsFqirsPCEZtAUEH9wWY4bFKU2bi1xQt5x39CP/QdE7cGJRyF2hXshvwL/wAAOPLP0PmCoiRcs7YPDO9/I1kENDVFfpdej189t6GhTd3XYLJ9DUdLmlq8ceccPNyiuweJ4EGSIw36e9/UHBJbLOZ98nX7/MZ+/+6w+TrgC2T+eUlCpp9rwhy03x0H7XXHka29Lix0GorumBIzVqsVAwYMSHtRQMgTc8stt0Q9VlNTg2AwiD179qCyshKNjY3w+/1REZqDBw+ioqIi9nKmyEYPFj1kWUnr2jzSYLWIGa+Nl0b7A+mthdMSFgJOuxR1HVEIeVMCQQUNzT50LxajqnAUdzOUhr0AAKH7oLg1SOFoidcvq8e4x8RutSRes8YCxM+3SmLc2oCQ0AoGFfjCAkgSE+8r9wO5vcG4c1rDviCHLcm6NPCeNa2egO75fJ8sohB1nJum/UEF/oAMMUU6ixubRUFot8+ylnQ/10R60H53HLTXHUdH7XWHJw4rKiqwadOmqMc2bdoEQRDQt29fnHTSSVAURTUCA8D27dtx4MAB1NXVdfRy2xVvFkuzVQNwhh+a2O6/HEEQIhVN4QiBrDEbi4e3hv63pCcER3xqhr9HvXEGycqfLaIAfotvC79ufIlztAHYl6Cvi9569AzAZqvM+HymNq9+NVMgoL8eu6YqycjvTTUSkwGYIAgiig7/Vrzqqqvw6quv4vnnn8fu3buxdOlS/PGPf8TFF1+MoqIiVFRU4IwzzsDtt9+OFStWYN26dbjxxhsxduxY1NTUdPRy2xWjLfONoJZmZxg6dcd0/9Wi9poJl2dzYysAsIOhmUGWyiG61430VInvAJys/FkQBPW9aSMzWhKWZhuoZtLr8WJ2zITe5GwtATn0GrEiTFuqnajXTNR1dLofEwRBEO1QzZSKCy+8EHa7Hc888wzuv/9+VFRU4OKLL8Y111yjnnPXXXfh97//PebOnQsAmDx5Mm6//faOXmq7o5ZmpxmZ8XzyOJTDO+GcMS+uuVy68OiHS0fMFLiiy7N5jxlBAJT6zQAAS4/Bcc8D9LvdqiMD7Mk/hpIllN5SPTMxfVb4zV1WGGRFiZRmpzFoEoi8P22fnWTwvfIkKM1WuxbHrFsUBDV1p9cFOBYSMwRBEPq0q5h54YUXdB8/99xzce655yZ8nsvlwt1334277767nVaWexTG1L/GHWn0mVGaDyK4JdQ51/32H1FSciGAbKSZ+MTs+Bt5gRqZCaeZwpEZpyhDCQ9DjB1HwOFREm0EgnuGUkVArBYBHkTGLMSKFG3EIxhkCAQzGzTZ1BqKPBXn2+OO6ZEyMpNEhNitlrCYMZBmSiCKCIIgjnfoT7wcof1LPJ3ITGDb1+q/macJEw+8iHKxKeOp2ZG5TDpppljPTLgse4DtEMAUCAXdIOaX6V7XbtXxzISFRKrIDHey8zEL8WmmyM8BWVFTWYY6APviIyKNbaEWAIbFTKqmecHE67EZbJynvQ5FZgiCIKKhb8UcwVNMgpD8ppuI4LZQN2Rb3fkQS/vAIbfh+sIP4PAcTPHM5LSqnplkkZmwZyYsnPpLBwAkjsoAkZs2N+dq00GpxAyPvHChFes9EUVBrQwKBBVVGCSPzETSTIxFC0A+TLMoP77fkR6ZRGZUL1GCgZe616GGXwRBEFHQt2KO0FbMpOowG4vSfDCU1hFEWKumwHnmLWixV6BQ9OLkvYshh0uk00FvYjaHe2Z4ZIb7c/pZUosZNTITFg9eEyMDuAGYe2b0RAF/zB+QTY0zUBiLS801hcvTi/MMipnwXgWCipri0sLFlV56KBKZSZ5mkhX9UQ4EQRAEiZmc4c1gLhNPMVl6DoXoLIToKMC6fpdjT7AEDqUN7n/+HvKBLWmti6dK9AzA+XGeGQYLZPQRDgEApB76lUxARFgwhEQQr2SySqJqXk4ELztXS7OTiBltdCRZxEub2os1ATeGPTNFBtNMDrtFLR9366StUnlmAKQ0AGsFF4kZgiCIaOhbMUf41B4z5j3Ywa2hFJPUX9N3x16AP7echiPWHoCvDe537kVw5xpT11UYi5Rm6xmAw56ZFo1n5gTpCCRBhuAshFBUmfDatqgyZEX1qjgN+IUiaSZ9z4z2MW2vl2R9ZkRB0PSaiQggf0BWhVaxwTSTKAhqqsyt02smuWcm9eRsIDpyQ2KGIAgiGvpWzBFqmslkZEZpOgDlSCjFJPU7SX1csghwMwc+LL4Alj4jAdkPz4cPw7/xM8PX9viCasNdfQNwOM2kemYUDOB+mYpBSdNlFlFUIyz+gGzY/Bt6bzGeGT0xE2MStogCLGLyjzffe21kpjGcYrJKoqG1cZKZgJN7ZsJeohSRGd5BU7IIKTsFEwRBHG+QmMkRvjS7/wbCxl9Lz6EQHQXq49xX4pUlOE+fB2nwRIAp8H3+DHzfvBVnctWDl2XbrPqpHx6ZafMGISsKggrDAClkOE7UX0aLXVOeHen+a0TMCFHr0/Oe8Md4ZCaZX4bj0OkC3NQaNv/m2Ux5mZKZgP1ZTDNRVIYgCCIe+mbMEUZ7rMQSDPtlpAFjox63aprmCaIEx5TZsNWcCQDwr3oT3k+fAAvGD/DUwj0peuZfpeUw7DuXwSmErtHqCUIOyuinipnEfhmONqXiMZFmiovM6AgtfpPn5uRkKSaOXuM8sz1mOEYiM3oCS+2/k8IATJVMBEEQienwDsBECD6XyYyYUZrqoRzZFUoxnTg66lhsB2BBEGAf+1MI+aXw/XsxgluWwd24D84Z8xL2gtEbZaC0NcD/7dsIbPwMUGTcVFSIp1qmoNXth6V5L5xiAD5YkV96Qsr1axvnmUozcT+MAQMwTzPZDTSW02uc19hqriyb40wSmeEVTnpCxKbTGVkPmstEEASRGBIzOcKXRjWTmmLqNSwqxQRExEwgZpyBbdipEIt7wLv0MSiHd8L9xkI4TpurW3nEUzQuhxWKuxH+Ne8isOFTQA7foK0OdAs044bC99G2tRj2tiYAQL3YA91S+FMAwK4pn+YGYCNzqSJRp1CqTM9Iq1Yzec1EZnTSTGpZdrqRmWgDsMKYum6rzprsOp2R9eBih7r/EgRBxEN/5uWIdDwzaoqpf/z0cKsU8ncEg/HeGKnnULh+8huIZX3BvC3wvHMv/N9/FOej4Z6UIeIutL1yKwLffwTIQVh6DIHzrFuRd9Ei7BL7wC4EUbruBZTt+hgAUC/1MrR+mzrcMVKa7UwyMVtdf+yAxmQG4CS+mli4XyfKAJxmZMZlD6XmYiMzUSXVepEZVeClSDNRZIYgCCIh9M2YI7RN84ygNNZDObI71CjvxJPijqtpJkX/pigWdIPrnP8HacA4gMnwffUivB8+DOZtVc9xe/yY5vge01qWAAEPxG4nwjnrZjjPXACpxxCIjgJ8Wnw+PvKMCL1moA0AcMDa29B70EZm0kkzJfoZiERiWsOREbupyExEgDSpPWbMiZm8BMMmtWJGL1qkGoBTjDMgAzBBEERi6JsxR/AbqNE0U2DLVwBCKSbBkR93XBUzSYykgmSH49RrYf/RJYAoIbjzW7S9/msE920AC/oxcMdrONv1DQQA1qGnwHXO7ZB6D4+q6snPc+Adz2h81+dnkEUbmhQnjloT95fREjG7atNMBiIzYnRVUfLS7MyqmRrTNAA7HfqeGS5CREG/VFzdkxTjDMgATBAEkRjyzOQIn9+4Z4QF/Qis/xQAYB0ySfccfoMPysnTFYIgwDbiNFgqB8P78V+gNNXD8869EAq7o2frQchMwNaes3DSpAt0n8/Ls7dLAxEcdQte+eQHDC03FsXQjjTIJDKTrJpJFTMGIhi61Uwmh0xy1NLsuMhM2OuSIFJkdJwBRWYIgiASQ9+MOcJMNVNgyzIwbwuE/DJI/cbonhMxABubmm3p1heu8+6EdchkAAys+SB8ggOPtZyGpl7jEz6PD5ts9QTgE+zwMLs65DEV2jJkXpruNCDmYj0zelGXyPymYMJzYrFbo9NMQVlRRzWY9swkiMz4U0RU+KDJ2GqmWD8TiRmCIIjEUGQmRxitZmKMIfDdBwAA24jpEET983ljuWRpplgEqx2OKVfD0qca8u7vsHh3P2w5wjBNp88MJ98VmZzNp2ZbLEbFTMQzw2cYGYnMWGOur2+kDe2LrCSueIrFYY9O8TSHK5ksoqDOoTIKj8y0JfDMJKqu4gZwrQH4y3X78fLHP+DSGYMxbnhl1HVIzBAEQcRD34w5wmfQACzv+R5Kwz7A6oC1akrC86wWY2km3ef2r4NjytWo9+cB0B9lwFEnZ7sDkMNmY6ORGW0ZstdvopopNs2UpDSbk45nhvtlCvNspkcG8MnZnpjS7FRel9hxBuu2Hsaz72+E2xfEJ99Epp9TNRNBEERi6JsxR6hTs1OIGX84KmMdMhmCzZXwPH7Dj+0zYwa3ps9MItTJ2Z6AGgVJNfWaY9O07lfHGaSRZjImZsx4ZkJr4aMMjA6Y1KIdZ6BNEUUiKvq/Z5ummmlHfTP+suQ/UMLP37qvSe1onOo6BEEQxzMkZnJExDOT+GYuH90Dec/3QNi0mwx+w2cMasTELK3qxOxkkRmeZgqozeDMRmb8AQUeP08zZbfPDMdm4KbvjI3MhNNMRSYb5gERz0xQZlHl2LzkOlFEhYuZVk8AD766Dr6AjOEnlqBXtzwwBny37QgAqmYiCIJIBn0z5gifgchM4LsPAQDSiSdBLOye9Hram5xe47xUBGVFXZPebCZOgdOmns8jOammU3N4tMTrlyNpNhODJjnZSzNFVzNlEpmx2yzgmSmtCVj1zCQQM3bVR6Sguc2PPuX5+MVPqlEzqBsAYO2Ww6HjYVFkJOJEEARxvEHfjDlAYUz1SDgS3HQVT7PaW8ZWfXrKa0pS5IafTqpJewN2JREYdptFvTFzj4lRAzCPzPCRAYCxaqbYaIQhMWOoNDu6mqlRbZhnPjIjCoJueXYq465WdJUW2vHLC0bBaZcwckBoftb3246GJpRTZIYgCCIh9M2YA7RluIkiM4H1nwByEGJ5f4gVA1NeUxQEcEmRjgmY92dx2iWIKdJGvKKJt/6PjZwkgqd+eC8XySIYMrTGpZmS9JlRX8vkbCbGmBqZMVuWzdErz04lZlx2CUX5NuQ5JNxwwSiUFISE1ICeRchzSHD7gti6t5mqmQiCIJJApdk5gKc1BOhHEJgcDIkZALbqmVEdeBMhCAIkSUQgqJgqz+boTcxORIHThqPNPlXMGE0z2W2h8/jIACPmXyDNaiZDU7NDr89YKM3TmOaQSU5oPpM3KjLjTyFCJIuIu39+MoDo9J4oCqjuX4bl6w9g7dbDarRNb5QDQRDE8Q59M+YArV9GT6gEd34L5mmG4CqG1C9+DlMiEk3ONgLvj+IyIGZ4ZIaLEsNN82J6wRgx/wJpppkMeGZsVlGNZnn9waxFZlo9kTQa7wCcTFzlOay6PiWealq39QhFZgiCIJJA34w5INWQycDmLwEA1sETEjbJ04M3lwsa7AKspS1s5k1m/uXwiiYuSsx6ZjhG/DKAQQNwjOAxMmhSEAQ1zef2BdHcFtoDs6MMOJVlodL5XQciwzszESEj+pdBEIC9h9qw/4gbgDEvEEEQxPEGfTPmAG7+tevczJW2Bsi71wEArIP15zAlgqcg0vHMmEkzxXbHlUxWM3GMVDIB0Z4Zi5h8YCPHaD8WLiiPNHmhMAYBQGGeue6/nAE9CwEA2/Y1q49lImbynVYM7FUEAKg/6g5fh/rMEARBxEJiJgeokRmdVEjgh68AxmCpGASx2Ng0ao6aZkrDM9NmoGEeh3cB5qQbmUlWNaVFK2YSiYK4PjMGS5i5b4aLhQKX1bAHKJYBPUPCY0d9iyooU3lmUsFTTRyqZiIIgoiHvhlzAC8Fjq1kYowhsOkLAImnYycjk5EGbZ7UDfM4BTGRGbODJjkOg54Zrek1oZhJwzMDRCIzB456AKSfYgKA8hIn8p1WBGVFTTWl6jOTilEDukX9TJ4ZgiCIeOibMQckmsukHNgC1lQPSDZI/etMX1dSxYx5z4w7Dc8Mx3A1U0y0xKhnRjtoMlFkIvYmbzd40+e/g/qjbQDS6zHDEQQB/cOppq37mgBEDMDppod6dc9DaWFkTSRmCIIg4qFvxhwQGWUQfYPjURmp/1gINqfp6/LGeWlFZjLxzBhMM0kWEdriLcORGW2aKUHEJbZk2XhkhqeZQpGZdCuZOAPCHpete7mYySzNJAhCVHSGxAxBEEQ89M2YA9TSbM0NlwV8CGz7GkB6KSYgwzSTqchMrGfG2MdIEIQokWG4mklzA0+Urol93OhNnwuqo81eAOmNMtASawLO1DMDRPtmSMwQBEHEQ9+MOSBSzRS5sQe3rwQCXgiF5bBUDk7rupkYgN1p9JnhGPXMANECzmnUACya88xYRMHwJG9uwuaJuXSGTGrp16MQAoDDTV40tfoy9swAQFXfEtXQbNQ0TRAEcTxB34w5wOuLTzOpxt/BEw11/NVDyiAy02oiMpPvsEJARACYETPam3qiPjuxWKXUnhmLKEIUBCiMmRrGGNuFONPIjNMuoVf3POw51Iat+7IzhsButWDuedVoaPahtNCR0foIgiCORUjM5ABvIFzNFI4KKM0HIe/fBECAdfCEtK8b6TOTjgHYuGdGFAXkOa1oDc9zMhoFAaKjUUYjMxYDpdn8mC8gGxplwIkVVJkYgDn9exaFxUyTRsxk1h9mRL+y1CcRBEEcp1CaKQdEqplCN/PAxs8BAJbewyHmp3/T4lU/ZtNM/oCsPsdInxkguqLJXGRG65kxdoMXBUF9DWuSqAsXOuYiM9FrKM7LLDIDAAN6hSua9jbDr1Yz0f/VCIIg2gv6hs0B2mom5vfAv/5jAIB16NSMrptumolXMomCYHhekraiyWjTPCC6PNtoB2AgIgaSRThUMWMmMhOzhkyrmQBN87z9zao/isYQEARBtB/0DZsDtNVM/vWfAH4PxOIekE6szei66Y4zcKvdfyXDfh1tRZOZjrnaaiYzZlYu1JJ1wM00MpPnkLIyLqCyzAWXXYI/qOBosy9qbQRBEET2oW/YHMDHGTgtCgLffQAAsNWcCUHI7NdhTXNqtpmJ2RxtZMZonxkguprJTGSGv0ayCEdakRmNmMmGXwYIRbh487zYtREEQRDZh75hcwCPzBQfWAnmaYaQXwZp4MkZX1dNMwXNGYDN9JjhpO2Z0URNjHpmAE1kJpmYsfDIjBkxExFURVnwy3BIzBAEQXQc9A2bA7wBGSIU5G3/BABgGzULgph5YRmPXphPMxmvZOIURHlmTFQzhYWGRRRM3eBVz0w7GoAzLcvWwjsBc8xEiwiCIAhzZF3M7N+/HzfeeCMmTJiAuro6zJ49Gz/88EPUOe+//z5mzZqFkSNH4txzz8WyZcuijjc0NOBXv/oV6urqMHbsWNx5553weDzZXmrO8PllnGTbDounAYKzMO2Ov7FIHZhmivbMmInMhG7qDpvFVD8dI54Zm5pmSq9UPFtpJoAiMwRBEB1JVr9h/X4/5syZg0OHDuHxxx/HSy+9hLy8PFxxxRU4evQoAGD58uW4+eab8V//9V948803MX78eMyZMwdbt25VrzNv3jzs3LkTzz77LB566CF89tlnWLhwYTaXmjMUxuAPBHCa8zsAgLV6JgQpOxGBtKuZwv1i8pzG00zaLsCm+syExYzRHjMcY9VMoWPpppkymZgdS57Dih5lLs3aSMwQBEG0F1n9hl21ahU2b96M++67D9XV1Rg0aBAWLVoEt9uNTz4JpVSefPJJTJ8+HZdffjkGDBiA+fPnY/jw4XjuuecAAN9++y2+/vpr3HPPPRg+fDjGjx+P3/72t3jrrbdw4MCBbC43J/gDMkZad6PC0gzYXLANy6wcWwu/YQZN9plJK82UoWcmtvNuKox4ZqQMDcDZTDMBkRJtQTC3RwRBEIQ5stoBeNCgQXjiiSdQUVGhPiaGy3abm5uhKAq++eYbLFiwIOp5J598Mj788EMAIUHUvXt3DBgwQD0+duxYCIKA1atXY9asWWmvL3aycqbsXv8d1q75FIosw6jlVlEYznZtAQDYq0+D1ZWXtfXwiMSO+hYs/nCT4eet39EAIJQ6MrpH2iiG3WYx/DwekXE5JFO/Dy5ikr0W72HjsBtfj8UiQBAAxoDSQkdWPyOD+hThy+/2wyZZEk777oxwD5QZLxSRPrTfHQftdcfR0XudVTHTvXt3TJkyJeqxF154AV6vFxMmTEBzczPcbjcqKyujzikvL0d9fT0A4MCBA+jRo0fUcZvNhuLiYuzfvz/ttYmigJKS7AkHAPhu2Rs4wbc19YmxWAA/k9B38rmwZFHM9KwoABAacvjJN3tNP79PjyLDe+TKd6jelIryAsP9WXpVhLwk5aUuU7+PsiInAKCyW37C53UvDT1e2T3xObrXLnTgSLMXA/uWoaTEafh5qagb0RPPvLcRRQX2rH/2OoLCwuztBZEa2u+Og/a64+iovTYlZvbs2YNp06YlPL5s2TKUlpaqP3/00Uf405/+hCuvvBJDhgxRBYvNFh3Ot9vt8PlCzcU8Hk/c8dhz0kFRGJqb3Wk/X4/y6Zdjz9ovEQwEQ3/am6B0cA2afRbA15a19QyozMeVP65Cc5vf9HML82yo6l2Ihgbj67nxwhoojKG1xWv4OYN6FmD2mUMx/MRSU691/in9UTukO6r6FCV83vTRvVCab8OYQd1MXft/zqtGY6sPEhRTz0tFvk3E9T8didICe1av295YLCIKC51obvZATmNoKWEO2u+Og/a648jWXhcWOg1Fd0yJmYqKCrz33nsJjxcVRcpR//73v+Ouu+7C2WefjVtuuQVASJAAIaOwFp/PB6czpN4cDkfccX6Oy+WKe9wMZr0kqajo2w9VNSPQ0NCW1rWzvR4AmDyqZ/pPZubWNLhPMQDz72PCiB6mn1eSb8f0saVJ99pllzCx2vy1+1YUoG9FQbv8PmoHdjO9ns6CLCtdct1dFdrvjoP2uuPoqL02JWasVmuUlyURixYtwlNPPYWrrroK8+fPV0twi4uL4XK5cPDgwajzDx48qPpsKisrsXTp0qjjfr8fjY2NKC8vN7NcgiAIgiCOA7LuzOFCZv78+ViwYEFULxFBEDB69Gh8/fXXUc9ZsWIFxowZAwCoq6tDfX09du7cqR7n55900knZXi5BEARBEF2crBqAV6xYgaeeegqXXXYZzjrrLBw6dEg95nK5kJeXh6uuugpz5szBsGHDMHnyZLz++uvYsGEDfve73wEARo0ahdGjR+OGG27AwoUL4Xa7cccdd+Dcc8+NqpIiCIIgCIIAAIExk87VJPz617/GP/7xD91jc+fOxfXXXw8AWLJkCR577DHU19dj4MCBuPnmmzF+/Hj13CNHjuDOO+/EF198AbvdjpkzZ+LWW29VPTfpIMsKjh7NrglTkkSUlOSl7ZkhjEN73XHQXncstN8dB+11x5GtvS4tzTNkAM6qmOnMkJjp2tBedxy01x0L7XfHQXvdcXS0mKHOQQRBEARBdGlIzBAEQRAE0aUhMUMQBEEQRJeGxAxBEARBEF0aEjMEQRAEQXRpSMwQBEEQBNGlITFDEARBEESXhsQMQRAEQRBdmuOmaR5jDIqS/bdqsYg0Sr6DoL3uOGivOxba746D9rrjyMZei6IQNeMxEceNmCEIgiAI4tiE0kwEQRAEQXRpSMwQBEEQBNGlITFDEARBEESXhsQMQRAEQRBdGhIzBEEQBEF0aUjMEARBEATRpSExQxAEQRBEl4bEDEEQBEEQXRoSMwRBEARBdGlIzBAEQRAE0aUhMUMQBEEQRJeGxAxBEARBEF0aEjMEQRAEQXRpSMykiaIoePjhhzFp0iTU1NTgmmuuwe7du3O9rC5PY2Mj7rjjDkyePBmjR4/GRRddhFWrVqnHly1bhvPOOw+jRo3CzJkz8e677+ZwtccO27dvR21tLd544w31sQ0bNuDSSy9FTU0NTj31VDz//PM5XOGxwZIlSzBr1ixUV1fjjDPOwPvvv68e27NnD6699lqMHj0aEydOxIMPPghZlnO42q5LMBjEQw89hKlTp6K2thaXXHIJ1qxZox6nz3Z2+Otf/4rLLrss6rFUe9tu905GpMUjjzzCTj75ZPbpp5+yDRs2sKuvvprNmDGD+Xy+XC+tS3PVVVexM888k61cuZJt27aN3XnnnWzkyJFs69atbMuWLay6uprdf//9bMuWLeypp55iw4YNY1999VWul92l8fv97LzzzmODBw9mr7/+OmOMsaNHj7KTTz6Z3XrrrWzLli3stddeY9XV1ey1117L8Wq7LkuWLGHDhg1jixcvZjt37mSPPfYYq6qqYt988w3z+/1sxowZbM6cOWzTpk3so48+YmPHjmUPPfRQrpfdJXn44YfZhAkT2BdffMF27NjBbrvtNnbSSSexAwcO0Gc7SyxevJhVVVWxSy+9VH3MyN62172TxEwa+Hw+Vltby1588UX1saamJjZy5Ej29ttv53BlXZsdO3awwYMHs1WrVqmPKYrCpk+fzh588EH261//mv30pz+Nes6NN97Irr766o5e6jHFn/70J3b55ZdHiZnHH3+cTZw4kQUCgajzZsyYkatldmkURWFTp05lf/zjH6Mev/rqq9njjz/O3n77bTZixAjW2NioHnv55ZfZ6NGj6Q+kNDj77LPZH/7wB/XnlpYWNnjwYPbBBx/QZztD6uvr2bXXXstqamrYzJkzo8RMqr1tz3snpZnSYOPGjWhra8P48ePVxwoLCzFs2DCsXLkyhyvr2pSUlOCJJ55AdXW1+pggCBAEAc3NzVi1alXUngPAuHHjsHr1ajDGOnq5xwQrV67EK6+8gj/+8Y9Rj69atQpjx46FJEnqY+PGjcOOHTtw+PDhjl5ml2f79u3Yu3cvzjrrrKjHn376aVx77bVYtWoVhg8fjqKiIvXYuHHj0Nraig0bNnT0crs8ZWVl+PTTT7Fnzx7IsoxXXnkFNpsNVVVV9NnOkP/85z+wWq345z//iVGjRkUdS7W37XnvJDGTBvX19QCAHj16RD1eXl6uHiPMU1hYiClTpsBms6mPffDBB9i5cycmTZqE+vp6VFZWRj2nvLwcHo8HDQ0NHb3cLk9zczNuueUW3H777XGf5UR7DQD79+/vsDUeK2zfvh0A4Ha7MXv2bIwfPx4XXHABPvnkEwC039nmtttug9VqxbRp01BdXY0HHngADz/8ME444QTa6ww59dRT8cgjj6BPnz5xx1LtbXveO0nMpIHH4wGAqJsuANjtdvh8vlws6Zjkm2++wa233ooZM2bglFNOgdfrjdtz/rPf78/FErs0CxcuRG1tbVy0AIDuXtvtdgCgz3gatLa2AgDmz5+PM888E3/7298wYcIE/OIXv8CyZctov7PMli1bUFBQgD//+c945ZVXcN555+Gmm27Chg0baK/bkVR72573Tin1KUQsDocDQOgGyv8NhH5ZTqczV8s6pli6dCluuukmjB49Gvfddx+A0Ac+VrTwn2nfzbFkyRKsWrUKb7/9tu5xh8MRt9f8y8blcrX7+o41rFYrAGD27Nn4yU9+AgAYOnQo1q9fj2eeeYb2O4vs378fv/rVr/Dss89izJgxAIDq6mps2bIFjzzyCO11O5Jqb9vz3kmRmTTgIbKDBw9GPX7w4EFUVFTkYknHFIsXL8b111+PqVOn4vHHH1eVfY8ePXT33OVyoaCgIBdL7bK8/vrrOHLkCE455RTU1taitrYWAPCb3/wGP//5z1FZWam71wDoM54GfM8GDx4c9fjAgQOxZ88e2u8ssnbtWgQCgSjvHQCMGjUKO3fupL1uR1LtbXveO0nMpEFVVRXy8/OxYsUK9bHm5masX78edXV1OVxZ1+ell17CXXfdhUsuuQT3339/VDhyzJgx+Prrr6POX758OUaPHg1RpI+yGe677z689957WLJkifofAMybNw+/+93vUFdXh9WrV0f1OVm+fDn69euHsrKyHK266zJ8+HDk5eVh7dq1UY9v3rwZJ5xwAurq6rB+/Xo1HQWE9jsvLw9VVVUdvdwuDfdsbNq0KerxzZs348QTT6TPdjuSam/b9d6ZUS3Uccz999/Pxo4dy5YuXRpVK+/3+3O9tC7Ltm3b2PDhw9n//M//sIMHD0b919zczDZv3syGDx/OFi1axLZs2cKefvpp6jOTRbSl2YcPH2Z1dXVs/vz57IcffmCvv/46q66uZm+88UaOV9l1+fOf/8xqa2vZ22+/HdVnZvny5czr9bLp06ez2bNnsw0bNqh9Zh555JFcL7vLIcsyu+iii9jMmTPZsmXL2Pbt29kDDzzAhg4dytasWUOf7Swyf/78qNJsI3vbXvdOEjNpEgwG2b333svGjRvHampq2DXXXMN2796d62V1af7yl7+wwYMH6/43f/58xhhjn332GTvzzDPZiBEj2MyZM9m7776b41UfO2jFDGOMrV27lv3sZz9jI0aMYFOnTmUvvPBCDld3bPC3v/2NnXrqqWz48OHs7LPPZh999JF6bMeOHeyqq65i1dXVbOLEiezBBx9ksizncLVdl8bGRrZw4UJ2yimnsNraWnbhhReyFStWqMfps50dYsUMY6n3tr3unQJj1KCDIAiCIIiuCxkNCIIgCILo0pCYIQiCIAiiS0NihiAIgiCILg2JGYIgCIIgujQkZgiCIAiC6NKQmCEIgiAIoktDYoYgCIIgiC4NiRmCIAiCILo0JGYIgmhX6uvrcckll6C6uhrjx4+Hx+PJ9ZIIgjjGkHK9AIIgjm2ee+45rFmzBosWLUJFRQWcTmeul0QQxDEGiRmCINqVxsZGlJeXY9asWbleCkEQxyiUZiIIot049dRT8cYbb2Dfvn0YMmQILrvsMgwZMgQvv/wypk6ditGjR+Pf//43AODVV1/Feeedh5qaGowcORLnnHMO3n//ffVab7zxBqqrq7Fq1Sqcf/75qK6uxumnn45PPvkE27ZtwxVXXIFRo0bhtNNOw7vvvhu1jn379uHGG2/E2LFjMWrUKFxxxRVYv3591DnvvPMOzj77bIwcORLjxo3DTTfdhAMHDrT/JhEEkTE0aJIgiHZj/fr1ePDBB7F+/Xo8+uij2LlzJ2655RZ0794dt99+O7xeL2bMmIE333wTd999N66//nqcdNJJaGpqwpNPPon169fj448/RmVlJd544w3cdtttKC8vx9y5c9GjRw/cd9992LVrF7p164aLLroIVVVVePTRR7F27VosXboUlZWVOHr0KM4991w4nU7MnTsXTqcTzz33HL7//nu89tprGDBgAFavXo3LLrsMv/jFL1BXV4f6+nosWrQIJ554IhYvXpzrbSQIIgWUZiIIot0YNmwYSktLYbPZUFNTA5/PBwC4+OKLMXPmTPW83bt3Y/bs2fjFL36hPtarVy+cd955WL16Nc444wwAgKIouO6663DBBRcAAJqbm3HDDTfgiiuuwFVXXQUAKCgowPnnn4/vv/8elZWVeO6559DY2Ii///3v6NWrFwBg8uTJmDVrFh566CE8/PDDWL16NRwOB+bMmQObzQYAKC4uxnfffQfGGARBaP/NIggibUjMEATR4QwdOjTq5wULFgAIiZNt27Zh586dWLFiBQDA7/dHnVtbW6v+u6ysDAAwatQo9bHi4mL1WgCwbNkyDB06FBUVFQgGgwAAURQxefJk/POf/wQA1NXV4YEHHsCZZ56J008/HVOmTMHEiRMxZcqUbL1lgiDaERIzBEF0OC6XK+rnXbt24Y477sCyZctgtVrRv39/VFVVAQBiM+H5+flx10tWIdXY2IidO3di+PDhusc9Hg9qa2vxxBNP4Nlnn8UzzzyDJ554At26dcN1112Hyy67zOzbIwiigyExQxBETlEUBXPmzIHVasVrr72GoUOHQpIkbNmyBW+99VbG1y8oKMDYsWNxyy236B7naaVJkyZh0qRJ8Hg8WL58OZ5//nncfffdGDVqFEaOHJnxOgiCaD+omokgiJzS0NCA7du346c//Smqq6shSaG/sT7//HMAIbGTCWPHjsX27dvRr18/VFdXq/+99dZbeO2112CxWHDPPffg/PPPB2MMTqcTU6dOxfz58wGEKqEIgujcUGSGIIicUlZWhl69euHFF19EZWUlCgsL8cUXX+D5558HgIw7Bl955ZV46623cOWVV+Lqq69GSUkJ3nvvPfzjH//ArbfeCgAYN24cnnnmGSxYsABnn302AoEAnnrqKRQXF2PcuHEZv0eCINoXiswQBJFzHnvsMVRUVGDBggX45S9/ibVr1+Ivf/kL+vfvj1WrVmV07YqKCrz88svo1asXFi5ciOuuuw7r1q3D7373O1x55ZUAgClTpuC+++7DDz/8gLlz5+LGG2+E0+nE888/rxqKCYLovFCfGYIgCIIgujQUmSEIgiAIoktDYoYgCIIgiC4NiRmCIAiCILo0JGYIgiAIgujSkJghCIIgCKJLQ2KGIAiCIIguDYkZgiAIgiC6NCRmCIIgCILo0pCYIQiCIAiiS0NihiAIgiCILg2JGYIgCIIgujT/HxgZTiyiQYTiAAAAAElFTkSuQmCC"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import os\n",
    "\n",
    "def smooth(data: list, weight: float = 0.9):\n",
    "    '''用于平滑曲线，类似于Tensorboard中的smooth曲线\n",
    "    '''\n",
    "    last = data[0] \n",
    "    smoothed = []\n",
    "    for point in data:\n",
    "        smoothed_val = last * weight + (1 - weight) * point  # 计算平滑值\n",
    "        smoothed.append(smoothed_val)                    \n",
    "        last = smoothed_val                                \n",
    "    return smoothed\n",
    "\n",
    "def plot_rewards(cfg, frames, rewards):\n",
    "    ''' 画图\n",
    "    '''\n",
    "    sns.set_theme(style=\"darkgrid\")\n",
    "    plt.figure()  # 创建一个图形实例，方便同时多画几个图\n",
    "    plt.title(f\"{cfg.mode}ing curve on {cfg.device} of {cfg.algo_name} for {cfg.env_id}\")\n",
    "    plt.xlabel('frames')\n",
    "    plt.plot(frames, rewards, label='rewards')\n",
    "    plt.plot(frames, smooth(rewards), label='smoothed rewards')\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "\n",
    "def print_cfgs(cfg):\n",
    "    ''' 打印参数\n",
    "    '''\n",
    "    cfg_dict = vars(cfg)\n",
    "    print(\"Hyperparameters:\")\n",
    "    print(''.join(['=']*80))\n",
    "    tplt = \"{:^20}\\t{:^20}\\t{:^20}\"\n",
    "    print(tplt.format(\"Name\", \"Value\", \"Type\"))\n",
    "    for k,v in cfg_dict.items():\n",
    "        if v.__class__.__name__ == 'list':\n",
    "            v = str(v)\n",
    "        print(tplt.format(k,v,str(type(v))))   \n",
    "    print(''.join(['=']*80))\n",
    "\n",
    "def all_seed(seed: int = 0):\n",
    "    ''' 设置随机种子\n",
    "    '''\n",
    "    if seed == 0:\n",
    "        return\n",
    "    np.random.seed(seed)\n",
    "    random.seed(seed)\n",
    "    torch.manual_seed(seed) # config for CPU\n",
    "    torch.cuda.manual_seed(seed) # config for GPU\n",
    "    os.environ['PYTHONHASHSEED'] = str(seed) # config for python scripts\n",
    "    # config for cudnn\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.enabled = False  \n",
    "\n",
    "# 获取参数\n",
    "cfg = Config() \n",
    "all_seed(cfg.seed)\n",
    "print_cfgs(cfg)\n",
    "res = train(cfg)\n",
    "plot_rewards(cfg, res['frames'], res['rewards'])\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "name": "joyrl-book",
   "language": "python",
   "display_name": "Python (joyrl-book)"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.14"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
